]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Remove some controls from limited screen area of Smartphone.
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_wxMenu swig_types[14]
1356 #define SWIGTYPE_p_wxGridSizer swig_types[15]
1357 #define SWIGTYPE_p_wxFlexGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxInitDialogEvent swig_types[17]
1359 #define SWIGTYPE_p_wxItemContainer swig_types[18]
1360 #define SWIGTYPE_p_wxNcPaintEvent swig_types[19]
1361 #define SWIGTYPE_p_wxPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[21]
1363 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxControl swig_types[25]
1367 #define SWIGTYPE_p_wxFont swig_types[26]
1368 #define SWIGTYPE_p_wxMenuBarBase swig_types[27]
1369 #define SWIGTYPE_p_wxSetCursorEvent swig_types[28]
1370 #define SWIGTYPE_p_wxFSFile swig_types[29]
1371 #define SWIGTYPE_p_wxCaret swig_types[30]
1372 #define SWIGTYPE_ptrdiff_t swig_types[31]
1373 #define SWIGTYPE_std__ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_p_wxRegion swig_types[33]
1375 #define SWIGTYPE_p_wxPoint2D swig_types[34]
1376 #define SWIGTYPE_p_int swig_types[35]
1377 #define SWIGTYPE_p_wxSize swig_types[36]
1378 #define SWIGTYPE_p_wxDC swig_types[37]
1379 #define SWIGTYPE_p_wxPySizer swig_types[38]
1380 #define SWIGTYPE_p_wxVisualAttributes swig_types[39]
1381 #define SWIGTYPE_p_wxNotifyEvent swig_types[40]
1382 #define SWIGTYPE_p_wxPyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPropagationDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxAppTraits swig_types[44]
1386 #define SWIGTYPE_p_wxArrayString swig_types[45]
1387 #define SWIGTYPE_p_wxShowEvent swig_types[46]
1388 #define SWIGTYPE_p_wxToolTip swig_types[47]
1389 #define SWIGTYPE_p_wxMoveEvent swig_types[48]
1390 #define SWIGTYPE_p_wxSizeEvent swig_types[49]
1391 #define SWIGTYPE_p_wxActivateEvent swig_types[50]
1392 #define SWIGTYPE_p_wxIconizeEvent swig_types[51]
1393 #define SWIGTYPE_p_wxMaximizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[53]
1395 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[54]
1396 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
1397 #define SWIGTYPE_p_wxMenuItem swig_types[56]
1398 #define SWIGTYPE_p_wxStaticBox swig_types[57]
1399 #define SWIGTYPE_p_long swig_types[58]
1400 #define SWIGTYPE_p_wxDuplexMode swig_types[59]
1401 #define SWIGTYPE_p_wxTIFFHandler swig_types[60]
1402 #define SWIGTYPE_p_wxXPMHandler swig_types[61]
1403 #define SWIGTYPE_p_wxPNMHandler swig_types[62]
1404 #define SWIGTYPE_p_wxJPEGHandler swig_types[63]
1405 #define SWIGTYPE_p_wxPCXHandler swig_types[64]
1406 #define SWIGTYPE_p_wxGIFHandler swig_types[65]
1407 #define SWIGTYPE_p_wxPNGHandler swig_types[66]
1408 #define SWIGTYPE_p_wxANIHandler swig_types[67]
1409 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[68]
1410 #define SWIGTYPE_p_wxZipFSHandler swig_types[69]
1411 #define SWIGTYPE_p_wxInternetFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[71]
1413 #define SWIGTYPE_p_wxEvtHandler swig_types[72]
1414 #define SWIGTYPE_p_wxCURHandler swig_types[73]
1415 #define SWIGTYPE_p_wxICOHandler swig_types[74]
1416 #define SWIGTYPE_p_wxBMPHandler swig_types[75]
1417 #define SWIGTYPE_p_wxImageHandler swig_types[76]
1418 #define SWIGTYPE_p_wxFileSystemHandler swig_types[77]
1419 #define SWIGTYPE_p_wxRect swig_types[78]
1420 #define SWIGTYPE_p_wxButton swig_types[79]
1421 #define SWIGTYPE_p_wxGBSpan swig_types[80]
1422 #define SWIGTYPE_p_wxPropagateOnce swig_types[81]
1423 #define SWIGTYPE_p_wxAcceleratorTable swig_types[82]
1424 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[83]
1425 #define SWIGTYPE_p_char swig_types[84]
1426 #define SWIGTYPE_p_wxGBPosition swig_types[85]
1427 #define SWIGTYPE_p_wxImage swig_types[86]
1428 #define SWIGTYPE_p_wxFrame swig_types[87]
1429 #define SWIGTYPE_p_wxScrollWinEvent swig_types[88]
1430 #define SWIGTYPE_p_wxPaperSize swig_types[89]
1431 #define SWIGTYPE_p_wxImageHistogram swig_types[90]
1432 #define SWIGTYPE_p_wxPoint swig_types[91]
1433 #define SWIGTYPE_p_wxCursor swig_types[92]
1434 #define SWIGTYPE_p_wxObject swig_types[93]
1435 #define SWIGTYPE_p_wxInputStream swig_types[94]
1436 #define SWIGTYPE_p_wxOutputStream swig_types[95]
1437 #define SWIGTYPE_p_wxPyInputStream swig_types[96]
1438 #define SWIGTYPE_p_wxDateTime swig_types[97]
1439 #define SWIGTYPE_p_wxKeyEvent swig_types[98]
1440 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[99]
1441 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[100]
1442 #define SWIGTYPE_p_unsigned_long swig_types[101]
1443 #define SWIGTYPE_p_wxWindow swig_types[102]
1444 #define SWIGTYPE_p_wxMenuBar swig_types[103]
1445 #define SWIGTYPE_p_wxFileSystem swig_types[104]
1446 #define SWIGTYPE_p_wxBitmap swig_types[105]
1447 #define SWIGTYPE_unsigned_int swig_types[106]
1448 #define SWIGTYPE_p_unsigned_int swig_types[107]
1449 #define SWIGTYPE_p_wxMenuEvent swig_types[108]
1450 #define SWIGTYPE_p_wxContextMenuEvent swig_types[109]
1451 #define SWIGTYPE_p_unsigned_char swig_types[110]
1452 #define SWIGTYPE_p_wxEraseEvent swig_types[111]
1453 #define SWIGTYPE_p_wxMouseEvent swig_types[112]
1454 #define SWIGTYPE_p_wxCloseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxPyApp swig_types[114]
1456 #define SWIGTYPE_p_wxCommandEvent swig_types[115]
1457 #define SWIGTYPE_p_wxPyCommandEvent swig_types[116]
1458 #define SWIGTYPE_p_wxPyDropTarget swig_types[117]
1459 #define SWIGTYPE_p_wxQuantize swig_types[118]
1460 #define SWIGTYPE_p_wxChildFocusEvent swig_types[119]
1461 #define SWIGTYPE_p_wxFocusEvent swig_types[120]
1462 #define SWIGTYPE_p_wxDropFilesEvent swig_types[121]
1463 #define SWIGTYPE_p_wxControlWithItems swig_types[122]
1464 #define SWIGTYPE_p_wxColour swig_types[123]
1465 #define SWIGTYPE_p_wxValidator swig_types[124]
1466 #define SWIGTYPE_p_wxPyValidator swig_types[125]
1467 static swig_type_info *swig_types[127];
1468
1469 /* -------- TYPES TABLE (END) -------- */
1470
1471
1472 /*-----------------------------------------------
1473 @(target):= _core_.so
1474 ------------------------------------------------*/
1475 #define SWIG_init init_core_
1476
1477 #define SWIG_name "_core_"
1478
1479 #include "wx/wxPython/wxPython_int.h"
1480 #include "wx/wxPython/pyclasses.h"
1481
1482
1483 #ifndef wxPyUSE_EXPORT
1484 // Helper functions for dealing with SWIG objects and such. These are
1485 // located here so they know about the SWIG types and functions declared
1486 // in the wrapper code.
1487
1488 #include <wx/hashmap.h>
1489 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1490
1491
1492 // Maintains a hashmap of className to swig_type_info pointers. Given the
1493 // name of a class either looks up the type info in the cache, or scans the
1494 // SWIG tables for it.
1495 extern PyObject* wxPyPtrTypeMap;
1496 static
1497 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1498
1499 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1500
1501 if (typeInfoCache == NULL)
1502 typeInfoCache = new wxPyTypeInfoHashMap;
1503
1504 wxString name(className);
1505 swig_type_info* swigType = (*typeInfoCache)[name];
1506
1507 if (! swigType) {
1508 // it wasn't in the cache, so look it up from SWIG
1509 name.Append(wxT(" *"));
1510 swigType = SWIG_TypeQuery(name.mb_str());
1511
1512 // if it still wasn't found, try looking for a mapped name
1513 if (!swigType) {
1514 PyObject* item;
1515 name = className;
1516
1517 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1518 (char*)(const char*)name.mbc_str())) != NULL) {
1519 name = wxString(PyString_AsString(item), *wxConvCurrent);
1520 name.Append(wxT(" *"));
1521 swigType = SWIG_TypeQuery(name.mb_str());
1522 }
1523 }
1524 if (swigType) {
1525 // and add it to the map if found
1526 (*typeInfoCache)[className] = swigType;
1527 }
1528 }
1529 return swigType;
1530 }
1531
1532
1533 // Check if a class name is a type known to SWIG
1534 bool wxPyCheckSwigType(const wxChar* className) {
1535
1536 swig_type_info* swigType = wxPyFindSwigType(className);
1537 return swigType != NULL;
1538 }
1539
1540
1541 // Given a pointer to a C++ object and a class name, construct a Python proxy
1542 // object for it.
1543 PyObject* wxPyConstructObject(void* ptr,
1544 const wxChar* className,
1545 int setThisOwn) {
1546
1547 swig_type_info* swigType = wxPyFindSwigType(className);
1548 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1549
1550 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1551 }
1552
1553
1554 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1555 // Ensures that the proxy object is of the specified (or derived) type. If
1556 // not able to perform the conversion then a Python exception is set and the
1557 // error should be handled properly in the caller. Returns True on success.
1558 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1559 const wxChar* className) {
1560
1561 swig_type_info* swigType = wxPyFindSwigType(className);
1562 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1563
1564 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1565 }
1566
1567
1568 // Make a SWIGified pointer object suitable for a .this attribute
1569 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1570
1571 PyObject* robj = NULL;
1572
1573 swig_type_info* swigType = wxPyFindSwigType(className);
1574 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1575
1576 #ifdef SWIG_COBJECT_TYPES
1577 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1578 #else
1579 {
1580 char result[1024];
1581 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1582 PyString_FromString(result) : 0;
1583 }
1584 #endif
1585
1586 return robj;
1587 }
1588
1589
1590
1591
1592 // Export a C API in a struct. Other modules will be able to load this from
1593 // the wx._core_ module and will then have safe access to these functions,
1594 // even if they are located in another shared library.
1595 static wxPyCoreAPI API = {
1596
1597 wxPyCheckSwigType,
1598 wxPyConstructObject,
1599 wxPyConvertSwigPtr,
1600 wxPyMakeSwigPtr,
1601
1602 wxPyBeginAllowThreads,
1603 wxPyEndAllowThreads,
1604 wxPyBeginBlockThreads,
1605 wxPyEndBlockThreads,
1606
1607 wxPy_ConvertList,
1608
1609 wxString_in_helper,
1610 Py2wxString,
1611 wx2PyString,
1612
1613 byte_LIST_helper,
1614 int_LIST_helper,
1615 long_LIST_helper,
1616 string_LIST_helper,
1617 wxPoint_LIST_helper,
1618 wxBitmap_LIST_helper,
1619 wxString_LIST_helper,
1620 wxAcceleratorEntry_LIST_helper,
1621
1622 wxSize_helper,
1623 wxPoint_helper,
1624 wxRealPoint_helper,
1625 wxRect_helper,
1626 wxColour_helper,
1627 wxPoint2D_helper,
1628
1629 wxPySimple_typecheck,
1630 wxColour_typecheck,
1631
1632 wxPyCBH_setCallbackInfo,
1633 wxPyCBH_findCallback,
1634 wxPyCBH_callCallback,
1635 wxPyCBH_callCallbackObj,
1636 wxPyCBH_delete,
1637
1638 wxPyMake_wxObject,
1639 wxPyMake_wxSizer,
1640 wxPyPtrTypeMap_Add,
1641 wxPy2int_seq_helper,
1642 wxPy4int_seq_helper,
1643 wxArrayString2PyList_helper,
1644 wxArrayInt2PyList_helper,
1645
1646 wxPyClientData_dtor,
1647 wxPyUserData_dtor,
1648 wxPyOORClientData_dtor,
1649
1650 wxPyCBInputStream_create,
1651
1652 wxPyInstance_Check,
1653 wxPySwigInstance_Check,
1654
1655 wxPyCheckForApp
1656
1657 };
1658
1659 #endif
1660
1661
1662 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1663 #define SWIG_From_int PyInt_FromLong
1664 /*@@*/
1665
1666
1667 #if ! wxUSE_HOTKEY
1668 enum wxHotkeyModifier
1669 {
1670 wxMOD_NONE = 0,
1671 wxMOD_ALT = 1,
1672 wxMOD_CONTROL = 2,
1673 wxMOD_SHIFT = 4,
1674 wxMOD_WIN = 8
1675 };
1676 #define wxEVT_HOTKEY 9999
1677 #endif
1678
1679 static const wxString wxPyEmptyString(wxEmptyString);
1680 static wxString wxObject_GetClassName(wxObject *self){
1681 return self->GetClassInfo()->GetClassName();
1682 }
1683 static void wxObject_Destroy(wxObject *self){
1684 delete self;
1685 }
1686
1687 #ifndef __WXMAC__
1688 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1689 #endif
1690
1691
1692 #include <limits.h>
1693
1694
1695 SWIGINTERN int
1696 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1697 const char *errmsg)
1698 {
1699 if (value < min_value) {
1700 if (errmsg) {
1701 PyErr_Format(PyExc_OverflowError,
1702 "value %ld is less than '%s' minimum %ld",
1703 value, errmsg, min_value);
1704 }
1705 return 0;
1706 } else if (value > max_value) {
1707 if (errmsg) {
1708 PyErr_Format(PyExc_OverflowError,
1709 "value %ld is greater than '%s' maximum %ld",
1710 value, errmsg, max_value);
1711 }
1712 return 0;
1713 }
1714 return 1;
1715 }
1716
1717
1718 SWIGINTERN int
1719 SWIG_AsVal_long(PyObject* obj, long* val)
1720 {
1721 if (PyNumber_Check(obj)) {
1722 if (val) *val = PyInt_AsLong(obj);
1723 return 1;
1724 }
1725 else {
1726 SWIG_type_error("number", obj);
1727 }
1728 return 0;
1729 }
1730
1731
1732 #if INT_MAX != LONG_MAX
1733 SWIGINTERN int
1734 SWIG_AsVal_int(PyObject *obj, int *val)
1735 {
1736 const char* errmsg = val ? "int" : (char*)0;
1737 long v;
1738 if (SWIG_AsVal_long(obj, &v)) {
1739 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1740 if (val) *val = (int)(v);
1741 return 1;
1742 } else {
1743 return 0;
1744 }
1745 } else {
1746 PyErr_Clear();
1747 }
1748 if (val) {
1749 SWIG_type_error(errmsg, obj);
1750 }
1751 return 0;
1752 }
1753 #else
1754 SWIGINTERNSHORT int
1755 SWIG_AsVal_int(PyObject *obj, int *val)
1756 {
1757 return SWIG_AsVal_long(obj,(long*)val);
1758 }
1759 #endif
1760
1761
1762 SWIGINTERNSHORT int
1763 SWIG_As_int(PyObject* obj)
1764 {
1765 int v;
1766 if (!SWIG_AsVal_int(obj, &v)) {
1767 /*
1768 this is needed to make valgrind/purify happier.
1769 */
1770 memset((void*)&v, 0, sizeof(int));
1771 }
1772 return v;
1773 }
1774
1775
1776 SWIGINTERNSHORT int
1777 SWIG_Check_int(PyObject* obj)
1778 {
1779 return SWIG_AsVal_int(obj, (int*)0);
1780 }
1781
1782 static PyObject *wxSize_Get(wxSize *self){
1783 bool blocked = wxPyBeginBlockThreads();
1784 PyObject* tup = PyTuple_New(2);
1785 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1786 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1787 wxPyEndBlockThreads(blocked);
1788 return tup;
1789 }
1790
1791 SWIGINTERN int
1792 SWIG_AsVal_double(PyObject *obj, double* val)
1793 {
1794 if (PyNumber_Check(obj)) {
1795 if (val) *val = PyFloat_AsDouble(obj);
1796 return 1;
1797 }
1798 else {
1799 SWIG_type_error("number", obj);
1800 }
1801 return 0;
1802 }
1803
1804
1805 SWIGINTERNSHORT double
1806 SWIG_As_double(PyObject* obj)
1807 {
1808 double v;
1809 if (!SWIG_AsVal_double(obj, &v)) {
1810 /*
1811 this is needed to make valgrind/purify happier.
1812 */
1813 memset((void*)&v, 0, sizeof(double));
1814 }
1815 return v;
1816 }
1817
1818
1819 SWIGINTERNSHORT int
1820 SWIG_Check_double(PyObject* obj)
1821 {
1822 return SWIG_AsVal_double(obj, (double*)0);
1823 }
1824
1825
1826 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1827 #define SWIG_From_double PyFloat_FromDouble
1828 /*@@*/
1829
1830 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1831 self->x = x;
1832 self->y = y;
1833 }
1834 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1835 bool blocked = wxPyBeginBlockThreads();
1836 PyObject* tup = PyTuple_New(2);
1837 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1838 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1839 wxPyEndBlockThreads(blocked);
1840 return tup;
1841 }
1842
1843 SWIGINTERNSHORT long
1844 SWIG_As_long(PyObject* obj)
1845 {
1846 long v;
1847 if (!SWIG_AsVal_long(obj, &v)) {
1848 /*
1849 this is needed to make valgrind/purify happier.
1850 */
1851 memset((void*)&v, 0, sizeof(long));
1852 }
1853 return v;
1854 }
1855
1856
1857 SWIGINTERNSHORT int
1858 SWIG_Check_long(PyObject* obj)
1859 {
1860 return SWIG_AsVal_long(obj, (long*)0);
1861 }
1862
1863 static void wxPoint_Set(wxPoint *self,long x,long y){
1864 self->x = x;
1865 self->y = y;
1866 }
1867 static PyObject *wxPoint_Get(wxPoint *self){
1868 bool blocked = wxPyBeginBlockThreads();
1869 PyObject* tup = PyTuple_New(2);
1870 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1871 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1872 wxPyEndBlockThreads(blocked);
1873 return tup;
1874 }
1875 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1876 self->x = x;
1877 self->y = y;
1878 self->width = width;
1879 self->height = height;
1880 }
1881 static PyObject *wxRect_Get(wxRect *self){
1882 bool blocked = wxPyBeginBlockThreads();
1883 PyObject* tup = PyTuple_New(4);
1884 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1885 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1886 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1887 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1888 wxPyEndBlockThreads(blocked);
1889 return tup;
1890 }
1891
1892 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1893 wxRegion reg1(*r1);
1894 wxRegion reg2(*r2);
1895 wxRect dest(0,0,0,0);
1896 PyObject* obj;
1897
1898 reg1.Intersect(reg2);
1899 dest = reg1.GetBox();
1900
1901 if (dest != wxRect(0,0,0,0)) {
1902 bool blocked = wxPyBeginBlockThreads();
1903 wxRect* newRect = new wxRect(dest);
1904 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1905 wxPyEndBlockThreads(blocked);
1906 return obj;
1907 }
1908 Py_INCREF(Py_None);
1909 return Py_None;
1910 }
1911
1912
1913 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1914 PyObject* o2;
1915 PyObject* o3;
1916
1917 if (!target) {
1918 target = o;
1919 } else if (target == Py_None) {
1920 Py_DECREF(Py_None);
1921 target = o;
1922 } else {
1923 if (!PyTuple_Check(target)) {
1924 o2 = target;
1925 target = PyTuple_New(1);
1926 PyTuple_SetItem(target, 0, o2);
1927 }
1928 o3 = PyTuple_New(1);
1929 PyTuple_SetItem(o3, 0, o);
1930
1931 o2 = target;
1932 target = PySequence_Concat(o2, o3);
1933 Py_DECREF(o2);
1934 Py_DECREF(o3);
1935 }
1936 return target;
1937 }
1938
1939
1940 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1941 self->m_x = x;
1942 self->m_y = y;
1943 }
1944 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1945 bool blocked = wxPyBeginBlockThreads();
1946 PyObject* tup = PyTuple_New(2);
1947 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1948 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1949 wxPyEndBlockThreads(blocked);
1950 return tup;
1951 }
1952
1953 #include "wx/wxPython/pyistream.h"
1954
1955 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1956 wxInputStream* wxis = wxPyCBInputStream::create(p);
1957 if (wxis)
1958 return new wxPyInputStream(wxis);
1959 else
1960 return NULL;
1961 }
1962
1963 SWIGINTERNSHORT PyObject*
1964 SWIG_From_char(char c)
1965 {
1966 return PyString_FromStringAndSize(&c,1);
1967 }
1968
1969
1970 SWIGINTERNSHORT PyObject*
1971 SWIG_From_unsigned_SS_long(unsigned long value)
1972 {
1973 return (value > LONG_MAX) ?
1974 PyLong_FromUnsignedLong(value)
1975 : PyInt_FromLong((long)(value));
1976 }
1977
1978
1979 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1980 SWIGINTERN int
1981 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1982 {
1983 static swig_type_info* pchar_info = 0;
1984 char* vptr = 0;
1985 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1986 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1987 if (cptr) *cptr = vptr;
1988 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1989 return SWIG_OLDOBJ;
1990 } else {
1991 PyErr_Clear();
1992 if (PyString_Check(obj)) {
1993 if (cptr) {
1994 *cptr = PyString_AS_STRING(obj);
1995 if (psize) {
1996 *psize = PyString_GET_SIZE(obj) + 1;
1997 }
1998 }
1999 return SWIG_PYSTR;
2000 }
2001 }
2002 if (cptr) {
2003 SWIG_type_error("char *", obj);
2004 }
2005 return 0;
2006 }
2007
2008
2009 SWIGINTERN int
2010 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2011 {
2012 char* cptr; size_t csize;
2013 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2014 /* in C you can do:
2015
2016 char x[5] = "hello";
2017
2018 ie, assing the array using an extra '0' char.
2019 */
2020 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2021 if (csize <= size) {
2022 if (val) {
2023 if (csize) memcpy(val, cptr, csize);
2024 if (csize < size) memset(val + csize, 0, size - csize);
2025 }
2026 return 1;
2027 }
2028 }
2029 if (val) {
2030 PyErr_Format(PyExc_TypeError,
2031 "a char array of maximum size %lu is expected",
2032 (unsigned long) size);
2033 }
2034 return 0;
2035 }
2036
2037
2038 SWIGINTERN int
2039 SWIG_AsVal_char(PyObject *obj, char *val)
2040 {
2041 const char* errmsg = val ? "char" : (char*)0;
2042 long v;
2043 if (SWIG_AsVal_long(obj, &v)) {
2044 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2045 if (val) *val = (char)(v);
2046 return 1;
2047 } else {
2048 return 0;
2049 }
2050 } else {
2051 PyErr_Clear();
2052 return SWIG_AsCharArray(obj, val, 1);
2053 }
2054 }
2055
2056
2057 SWIGINTERNSHORT char
2058 SWIG_As_char(PyObject* obj)
2059 {
2060 char v;
2061 if (!SWIG_AsVal_char(obj, &v)) {
2062 /*
2063 this is needed to make valgrind/purify happier.
2064 */
2065 memset((void*)&v, 0, sizeof(char));
2066 }
2067 return v;
2068 }
2069
2070
2071 SWIGINTERNSHORT int
2072 SWIG_Check_char(PyObject* obj)
2073 {
2074 return SWIG_AsVal_char(obj, (char*)0);
2075 }
2076
2077
2078 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2079 #define SWIG_From_long PyInt_FromLong
2080 /*@@*/
2081
2082 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2083 // We use only strings for the streams, not unicode
2084 PyObject* str = PyObject_Str(obj);
2085 if (! str) {
2086 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2087 return;
2088 }
2089 self->Write(PyString_AS_STRING(str),
2090 PyString_GET_SIZE(str));
2091 Py_DECREF(str);
2092 }
2093
2094 #include "wx/wxPython/pyistream.h"
2095
2096
2097 class wxPyFileSystemHandler : public wxFileSystemHandler
2098 {
2099 public:
2100 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2101
2102 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2103 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2104 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2105 DEC_PYCALLBACK_STRING__pure(FindNext);
2106
2107 wxString GetProtocol(const wxString& location) {
2108 return wxFileSystemHandler::GetProtocol(location);
2109 }
2110
2111 wxString GetLeftLocation(const wxString& location) {
2112 return wxFileSystemHandler::GetLeftLocation(location);
2113 }
2114
2115 wxString GetAnchor(const wxString& location) {
2116 return wxFileSystemHandler::GetAnchor(location);
2117 }
2118
2119 wxString GetRightLocation(const wxString& location) {
2120 return wxFileSystemHandler::GetRightLocation(location);
2121 }
2122
2123 wxString GetMimeTypeFromExt(const wxString& location) {
2124 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2125 }
2126
2127 PYPRIVATE;
2128 };
2129
2130
2131 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2132 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2133 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2134 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2135
2136
2137 SWIGINTERN int
2138 SWIG_AsVal_bool(PyObject *obj, bool *val)
2139 {
2140 if (obj == Py_True) {
2141 if (val) *val = true;
2142 return 1;
2143 }
2144 if (obj == Py_False) {
2145 if (val) *val = false;
2146 return 1;
2147 }
2148 int res = 0;
2149 if (SWIG_AsVal_int(obj, &res)) {
2150 if (val) *val = res ? true : false;
2151 return 1;
2152 } else {
2153 PyErr_Clear();
2154 }
2155 if (val) {
2156 SWIG_type_error("bool", obj);
2157 }
2158 return 0;
2159 }
2160
2161
2162 SWIGINTERNSHORT bool
2163 SWIG_As_bool(PyObject* obj)
2164 {
2165 bool v;
2166 if (!SWIG_AsVal_bool(obj, &v)) {
2167 /*
2168 this is needed to make valgrind/purify happier.
2169 */
2170 memset((void*)&v, 0, sizeof(bool));
2171 }
2172 return v;
2173 }
2174
2175
2176 SWIGINTERNSHORT int
2177 SWIG_Check_bool(PyObject* obj)
2178 {
2179 return SWIG_AsVal_bool(obj, (bool*)0);
2180 }
2181
2182 static wxString FileSystem_URLToFileName(wxString const &url){
2183 wxFileName fname = wxFileSystem::URLToFileName(url);
2184 return fname.GetFullPath();
2185 }
2186
2187 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2188 wxImage& image,
2189 long type) {
2190 wxMemoryFSHandler::AddFile(filename, image, type);
2191 }
2192
2193 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2194 const wxBitmap& bitmap,
2195 long type) {
2196 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2197 }
2198
2199 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2200 PyObject* data) {
2201 if (! PyString_Check(data)) {
2202 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2203 "Expected string object"));
2204 return;
2205 }
2206
2207 bool blocked = wxPyBeginBlockThreads();
2208 void* ptr = (void*)PyString_AsString(data);
2209 size_t size = PyString_Size(data);
2210 wxPyEndBlockThreads(blocked);
2211
2212 wxMemoryFSHandler::AddFile(filename, ptr, size);
2213 }
2214
2215
2216 #include "wx/wxPython/pyistream.h"
2217
2218
2219 SWIGINTERN int
2220 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2221 {
2222 long v = 0;
2223 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2224 SWIG_type_error("unsigned number", obj);
2225 }
2226 else if (val)
2227 *val = (unsigned long)v;
2228 return 1;
2229 }
2230
2231
2232 SWIGINTERNSHORT int
2233 SWIG_CheckUnsignedLongInRange(unsigned long value,
2234 unsigned long max_value,
2235 const char *errmsg)
2236 {
2237 if (value > max_value) {
2238 if (errmsg) {
2239 PyErr_Format(PyExc_OverflowError,
2240 "value %lu is greater than '%s' minimum %lu",
2241 value, errmsg, max_value);
2242 }
2243 return 0;
2244 }
2245 return 1;
2246 }
2247
2248
2249 SWIGINTERN int
2250 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2251 {
2252 const char* errmsg = val ? "unsigned char" : (char*)0;
2253 unsigned long v;
2254 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2255 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2256 if (val) *val = (unsigned char)(v);
2257 return 1;
2258 } else {
2259 return 0;
2260 }
2261 } else {
2262 PyErr_Clear();
2263 }
2264 if (val) {
2265 SWIG_type_error(errmsg, obj);
2266 }
2267 return 0;
2268 }
2269
2270
2271 SWIGINTERNSHORT unsigned char
2272 SWIG_As_unsigned_SS_char(PyObject* obj)
2273 {
2274 unsigned char v;
2275 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2276 /*
2277 this is needed to make valgrind/purify happier.
2278 */
2279 memset((void*)&v, 0, sizeof(unsigned char));
2280 }
2281 return v;
2282 }
2283
2284
2285 SWIGINTERNSHORT int
2286 SWIG_Check_unsigned_SS_char(PyObject* obj)
2287 {
2288 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2289 }
2290
2291
2292 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2293 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2294 /*@@*/
2295
2296
2297 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2298 if (width > 0 && height > 0)
2299 return new wxImage(width, height, clear);
2300 else
2301 return new wxImage;
2302 }
2303 static wxImage *new_wxImage(wxBitmap const &bitmap){
2304 return new wxImage(bitmap.ConvertToImage());
2305 }
2306 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2307 // Copy the source data so the wxImage can clean it up later
2308 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2309 if (copy == NULL) {
2310 PyErr_NoMemory();
2311 return NULL;
2312 }
2313 memcpy(copy, data, width*height*3);
2314 return new wxImage(width, height, copy, false);
2315 }
2316 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2317 // Copy the source data so the wxImage can clean it up later
2318 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2319 if (dcopy == NULL) {
2320 PyErr_NoMemory();
2321 return NULL;
2322 }
2323 memcpy(dcopy, data, width*height*3);
2324 unsigned char* acopy = (unsigned char*)malloc(width*height);
2325 if (acopy == NULL) {
2326 PyErr_NoMemory();
2327 return NULL;
2328 }
2329 memcpy(acopy, alpha, width*height);
2330
2331 return new wxImage(width, height, dcopy, acopy, false);
2332 }
2333 static wxSize wxImage_GetSize(wxImage *self){
2334 wxSize size(self->GetWidth(), self->GetHeight());
2335 return size;
2336 }
2337 static PyObject *wxImage_GetData(wxImage *self){
2338 unsigned char* data = self->GetData();
2339 int len = self->GetWidth() * self->GetHeight() * 3;
2340 PyObject* rv;
2341 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2342 return rv;
2343 }
2344 static void wxImage_SetData(wxImage *self,PyObject *data){
2345 unsigned char* dataPtr;
2346
2347 if (! PyString_Check(data)) {
2348 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2349 "Expected string object"));
2350 return /* NULL */ ;
2351 }
2352
2353 size_t len = self->GetWidth() * self->GetHeight() * 3;
2354 dataPtr = (unsigned char*) malloc(len);
2355 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2356 self->SetData(dataPtr);
2357 // wxImage takes ownership of dataPtr...
2358 }
2359 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2360 unsigned char* data = self->GetData();
2361 int len = self->GetWidth() * self->GetHeight() * 3;
2362 PyObject* rv;
2363 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2364 return rv;
2365 }
2366 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2367 unsigned char* buffer;
2368 int size;
2369
2370 bool blocked = wxPyBeginBlockThreads();
2371 if (!PyArg_Parse(data, "t#", &buffer, &size))
2372 goto done;
2373
2374 if (size != self->GetWidth() * self->GetHeight() * 3) {
2375 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2376 goto done;
2377 }
2378 self->SetData(buffer);
2379 done:
2380 wxPyEndBlockThreads(blocked);
2381 }
2382 static PyObject *wxImage_GetAlphaData(wxImage *self){
2383 unsigned char* data = self->GetAlpha();
2384 if (! data) {
2385 RETURN_NONE();
2386 } else {
2387 int len = self->GetWidth() * self->GetHeight();
2388 PyObject* rv;
2389 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2390 return rv;
2391 }
2392 }
2393 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2394 unsigned char* dataPtr;
2395
2396 if (! PyString_Check(data)) {
2397 PyErr_SetString(PyExc_TypeError, "Expected string object");
2398 return /* NULL */ ;
2399 }
2400
2401 size_t len = self->GetWidth() * self->GetHeight();
2402 dataPtr = (unsigned char*) malloc(len);
2403 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2404 self->SetAlpha(dataPtr);
2405 // wxImage takes ownership of dataPtr...
2406 }
2407 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2408 unsigned char* data = self->GetAlpha();
2409 int len = self->GetWidth() * self->GetHeight();
2410 PyObject* rv;
2411 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2412 return rv;
2413 }
2414 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2415 unsigned char* buffer;
2416 int size;
2417
2418 bool blocked = wxPyBeginBlockThreads();
2419 if (!PyArg_Parse(data, "t#", &buffer, &size))
2420 goto done;
2421
2422 if (size != self->GetWidth() * self->GetHeight()) {
2423 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2424 goto done;
2425 }
2426 self->SetAlpha(buffer);
2427 done:
2428 wxPyEndBlockThreads(blocked);
2429 }
2430
2431 SWIGINTERNSHORT unsigned long
2432 SWIG_As_unsigned_SS_long(PyObject* obj)
2433 {
2434 unsigned long v;
2435 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2436 /*
2437 this is needed to make valgrind/purify happier.
2438 */
2439 memset((void*)&v, 0, sizeof(unsigned long));
2440 }
2441 return v;
2442 }
2443
2444
2445 SWIGINTERNSHORT int
2446 SWIG_Check_unsigned_SS_long(PyObject* obj)
2447 {
2448 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2449 }
2450
2451 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2452 wxBitmap bitmap(*self, depth);
2453 return bitmap;
2454 }
2455 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2456 wxImage mono = self->ConvertToMono( red, green, blue );
2457 wxBitmap bitmap( mono, 1 );
2458 return bitmap;
2459 }
2460 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2461 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2462 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2463 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2464 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2465
2466 #include <wx/quantize.h>
2467
2468 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2469 return wxQuantize::Quantize(src, dest,
2470 //NULL, // palette
2471 desiredNoColours,
2472 NULL, // eightBitData
2473 flags);
2474 }
2475 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2476 if (PyCallable_Check(func)) {
2477 self->Connect(id, lastId, eventType,
2478 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2479 new wxPyCallback(func));
2480 }
2481 else if (func == Py_None) {
2482 self->Disconnect(id, lastId, eventType,
2483 (wxObjectEventFunction)
2484 &wxPyCallback::EventThunker);
2485 }
2486 else {
2487 wxPyBLOCK_THREADS(
2488 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2489 }
2490 }
2491 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2492 return self->Disconnect(id, lastId, eventType,
2493 (wxObjectEventFunction)
2494 &wxPyCallback::EventThunker);
2495 }
2496 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2497 if (_self && _self != Py_None) {
2498 self->SetClientObject(new wxPyOORClientData(_self, incref));
2499 }
2500 else {
2501 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2502 if (data) {
2503 self->SetClientObject(NULL); // This will delete it too
2504 }
2505 }
2506 }
2507
2508 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2509 #if wxUSE_UNICODE
2510 return self->GetUnicodeKey();
2511 #else
2512 return 0;
2513 #endif
2514 }
2515
2516 #if UINT_MAX < LONG_MAX
2517 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2518 #define SWIG_From_unsigned_SS_int SWIG_From_long
2519 /*@@*/
2520 #else
2521 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2522 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2523 /*@@*/
2524 #endif
2525
2526
2527 #if UINT_MAX != ULONG_MAX
2528 SWIGINTERN int
2529 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2530 {
2531 const char* errmsg = val ? "unsigned int" : (char*)0;
2532 unsigned long v;
2533 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2534 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2535 if (val) *val = (unsigned int)(v);
2536 return 1;
2537 }
2538 } else {
2539 PyErr_Clear();
2540 }
2541 if (val) {
2542 SWIG_type_error(errmsg, obj);
2543 }
2544 return 0;
2545 }
2546 #else
2547 SWIGINTERNSHORT unsigned int
2548 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2549 {
2550 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2551 }
2552 #endif
2553
2554
2555 SWIGINTERNSHORT unsigned int
2556 SWIG_As_unsigned_SS_int(PyObject* obj)
2557 {
2558 unsigned int v;
2559 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2560 /*
2561 this is needed to make valgrind/purify happier.
2562 */
2563 memset((void*)&v, 0, sizeof(unsigned int));
2564 }
2565 return v;
2566 }
2567
2568
2569 SWIGINTERNSHORT int
2570 SWIG_Check_unsigned_SS_int(PyObject* obj)
2571 {
2572 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2573 }
2574
2575 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2576 self->m_size = size;
2577 }
2578 static void wxMoveEvent_SetPosition(wxMoveEvent *self,wxPoint pos){
2579 self->m_pos = pos;
2580 }
2581 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2582 int count = self->GetNumberOfFiles();
2583 wxString* files = self->GetFiles();
2584 PyObject* list = PyList_New(count);
2585
2586 if (!list) {
2587 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2588 return NULL;
2589 }
2590
2591 for (int i=0; i<count; i++) {
2592 PyList_SetItem(list, i, wx2PyString(files[i]));
2593 }
2594 return list;
2595 }
2596
2597
2598 static wxPyApp *new_wxPyApp(){
2599 wxPythonApp = new wxPyApp();
2600 return wxPythonApp;
2601 }
2602
2603 void wxApp_CleanUp() {
2604 __wxPyCleanup();
2605 }
2606
2607
2608 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2609
2610
2611 SWIGINTERNSHORT int
2612 SWIG_AsCharPtr(PyObject *obj, char **val)
2613 {
2614 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2615 return 1;
2616 }
2617 if (val) {
2618 PyErr_Clear();
2619 SWIG_type_error("char *", obj);
2620 }
2621 return 0;
2622 }
2623
2624
2625 SWIGINTERN PyObject *
2626 SWIG_FromCharPtr(const char* cptr)
2627 {
2628 if (cptr) {
2629 size_t size = strlen(cptr);
2630 if (size > INT_MAX) {
2631 return SWIG_NewPointerObj((char*)(cptr),
2632 SWIG_TypeQuery("char *"), 0);
2633 } else {
2634 if (size != 0) {
2635 return PyString_FromStringAndSize(cptr, size);
2636 } else {
2637 return PyString_FromString(cptr);
2638 }
2639 }
2640 }
2641 Py_INCREF(Py_None);
2642 return Py_None;
2643 }
2644
2645
2646 #ifdef __WXMAC__
2647
2648 // A dummy class that raises an exception if used...
2649 class wxEventLoop
2650 {
2651 public:
2652 wxEventLoop() { wxPyRaiseNotImplemented(); }
2653 int Run() { return 0; }
2654 void Exit(int rc = 0) {}
2655 bool Pending() const { return false; }
2656 bool Dispatch() { return false; }
2657 bool IsRunning() const { return false; }
2658 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2659 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2660 };
2661
2662 #else
2663
2664 #include <wx/evtloop.h>
2665
2666 #endif
2667
2668
2669
2670 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2671 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2672 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2673 static PyObject *wxWindow_GetChildren(wxWindow *self){
2674 wxWindowList& list = self->GetChildren();
2675 return wxPy_ConvertList(&list);
2676 }
2677 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2678 #if wxUSE_HOTKEY
2679 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2680 #else
2681 return false;
2682 #endif
2683 }
2684 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2685
2686
2687
2688 return false;
2689
2690 }
2691 static long wxWindow_GetHandle(wxWindow *self){
2692 return wxPyGetWinHandle(self);
2693 }
2694 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2695 self->AssociateHandle((WXWidget)handle);
2696 }
2697
2698 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2699 return wxWindow::FindWindowById(id, parent);
2700 }
2701
2702 wxWindow* wxFindWindowByName( const wxString& name,
2703 const wxWindow *parent = NULL ) {
2704 return wxWindow::FindWindowByName(name, parent);
2705 }
2706
2707 wxWindow* wxFindWindowByLabel( const wxString& label,
2708 const wxWindow *parent = NULL ) {
2709 return wxWindow::FindWindowByLabel(label, parent);
2710 }
2711
2712
2713 #ifdef __WXMSW__
2714 #include <wx/msw/private.h> // to get wxGetWindowId
2715 #endif
2716
2717
2718 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2719 #ifdef __WXMSW__
2720 WXHWND hWnd = (WXHWND)_hWnd;
2721 long id = wxGetWindowId(hWnd);
2722 wxWindow* win = new wxWindow;
2723 parent->AddChild(win);
2724 win->SetEventHandler(win);
2725 win->SetHWND(hWnd);
2726 win->SetId(id);
2727 win->SubclassWin(hWnd);
2728 win->AdoptAttributesFromHWND();
2729 win->SetupColours();
2730 return win;
2731 #else
2732 wxPyRaiseNotImplemented();
2733 return NULL;
2734 #endif
2735 }
2736
2737
2738 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2739 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2740 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2741
2742 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2743
2744 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2745 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2746 wxMenuItemList& list = self->GetMenuItems();
2747 return wxPy_ConvertList(&list);
2748 }
2749 static const wxString wxPyControlNameStr(wxControlNameStr);
2750 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2751 if (clientData) {
2752 wxPyClientData* data = new wxPyClientData(clientData);
2753 return self->Append(item, data);
2754 } else
2755 return self->Append(item);
2756 }
2757 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2758 if (clientData) {
2759 wxPyClientData* data = new wxPyClientData(clientData);
2760 return self->Insert(item, pos, data);
2761 } else
2762 return self->Insert(item, pos);
2763 }
2764 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2765 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2766 if (data) {
2767 Py_INCREF(data->m_obj);
2768 return data->m_obj;
2769 } else {
2770 Py_INCREF(Py_None);
2771 return Py_None;
2772 }
2773 }
2774 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2775 wxPyClientData* data = new wxPyClientData(clientData);
2776 self->SetClientObject(n, data);
2777 }
2778
2779
2780 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2781 wxPyUserData* data = NULL;
2782 if ( userData ) {
2783 bool blocked = wxPyBeginBlockThreads();
2784 data = new wxPyUserData(userData);
2785 wxPyEndBlockThreads(blocked);
2786 }
2787 return new wxSizerItem(window, proportion, flag, border, data);
2788 }
2789 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2790 wxPyUserData* data = NULL;
2791 if ( userData ) {
2792 bool blocked = wxPyBeginBlockThreads();
2793 data = new wxPyUserData(userData);
2794 wxPyEndBlockThreads(blocked);
2795 }
2796 return new wxSizerItem(width, height, proportion, flag, border, data);
2797 }
2798 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2799 wxPyUserData* data = NULL;
2800 if ( userData ) {
2801 bool blocked = wxPyBeginBlockThreads();
2802 data = new wxPyUserData(userData);
2803 wxPyEndBlockThreads(blocked);
2804 }
2805 return new wxSizerItem(sizer, proportion, flag, border, data);
2806 }
2807
2808 #include <float.h>
2809 SWIGINTERN int
2810 SWIG_CheckDoubleInRange(double value, double min_value,
2811 double max_value, const char* errmsg)
2812 {
2813 if (value < min_value) {
2814 if (errmsg) {
2815 PyErr_Format(PyExc_OverflowError,
2816 "value %g is less than %s minimum %g",
2817 value, errmsg, min_value);
2818 }
2819 return 0;
2820 } else if (value > max_value) {
2821 if (errmsg) {
2822 PyErr_Format(PyExc_OverflowError,
2823 "value %g is greater than %s maximum %g",
2824 value, errmsg, max_value);
2825 }
2826 return 0;
2827 }
2828 return 1;
2829 }
2830
2831
2832 SWIGINTERN int
2833 SWIG_AsVal_float(PyObject *obj, float *val)
2834 {
2835 const char* errmsg = val ? "float" : (char*)0;
2836 double v;
2837 if (SWIG_AsVal_double(obj, &v)) {
2838 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2839 if (val) *val = (float)(v);
2840 return 1;
2841 } else {
2842 return 0;
2843 }
2844 } else {
2845 PyErr_Clear();
2846 }
2847 if (val) {
2848 SWIG_type_error(errmsg, obj);
2849 }
2850 return 0;
2851 }
2852
2853
2854 SWIGINTERNSHORT float
2855 SWIG_As_float(PyObject* obj)
2856 {
2857 float v;
2858 if (!SWIG_AsVal_float(obj, &v)) {
2859 /*
2860 this is needed to make valgrind/purify happier.
2861 */
2862 memset((void*)&v, 0, sizeof(float));
2863 }
2864 return v;
2865 }
2866
2867
2868 SWIGINTERNSHORT int
2869 SWIG_Check_float(PyObject* obj)
2870 {
2871 return SWIG_AsVal_float(obj, (float*)0);
2872 }
2873
2874
2875 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2876 #define SWIG_From_float PyFloat_FromDouble
2877 /*@@*/
2878
2879 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2880 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2881 if (data) {
2882 Py_INCREF(data->m_obj);
2883 return data->m_obj;
2884 } else {
2885 Py_INCREF(Py_None);
2886 return Py_None;
2887 }
2888 }
2889
2890 // Figure out the type of the sizer item
2891
2892 struct wxPySizerItemInfo {
2893 wxPySizerItemInfo()
2894 : window(NULL), sizer(NULL), gotSize(false),
2895 size(wxDefaultSize), gotPos(false), pos(-1)
2896 {}
2897
2898 wxWindow* window;
2899 wxSizer* sizer;
2900 bool gotSize;
2901 wxSize size;
2902 bool gotPos;
2903 int pos;
2904 };
2905
2906 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2907
2908 wxPySizerItemInfo info;
2909 wxSize size;
2910 wxSize* sizePtr = &size;
2911
2912 // Find out what the type of the item is
2913 // try wxWindow
2914 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2915 PyErr_Clear();
2916 info.window = NULL;
2917
2918 // try wxSizer
2919 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2920 PyErr_Clear();
2921 info.sizer = NULL;
2922
2923 // try wxSize or (w,h)
2924 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2925 info.size = *sizePtr;
2926 info.gotSize = true;
2927 }
2928
2929 // or a single int
2930 if (checkIdx && PyInt_Check(item)) {
2931 info.pos = PyInt_AsLong(item);
2932 info.gotPos = true;
2933 }
2934 }
2935 }
2936
2937 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2938 // no expected type, figure out what kind of error message to generate
2939 if ( !checkSize && !checkIdx )
2940 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2941 else if ( checkSize && !checkIdx )
2942 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2943 else if ( !checkSize && checkIdx)
2944 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2945 else
2946 // can this one happen?
2947 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2948 }
2949
2950 return info;
2951 }
2952
2953 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2954 if (!self->GetClientObject())
2955 self->SetClientObject(new wxPyOORClientData(_self));
2956 }
2957 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2958
2959 wxPyUserData* data = NULL;
2960 bool blocked = wxPyBeginBlockThreads();
2961 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2962 if ( userData && (info.window || info.sizer || info.gotSize) )
2963 data = new wxPyUserData(userData);
2964 wxPyEndBlockThreads(blocked);
2965
2966 // Now call the real Add method if a valid item type was found
2967 if ( info.window )
2968 return self->Add(info.window, proportion, flag, border, data);
2969 else if ( info.sizer )
2970 return self->Add(info.sizer, proportion, flag, border, data);
2971 else if (info.gotSize)
2972 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
2973 proportion, flag, border, data);
2974 else
2975 return NULL;
2976 }
2977 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2978
2979 wxPyUserData* data = NULL;
2980 bool blocked = wxPyBeginBlockThreads();
2981 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2982 if ( userData && (info.window || info.sizer || info.gotSize) )
2983 data = new wxPyUserData(userData);
2984 wxPyEndBlockThreads(blocked);
2985
2986 // Now call the real Insert method if a valid item type was found
2987 if ( info.window )
2988 return self->Insert(before, info.window, proportion, flag, border, data);
2989 else if ( info.sizer )
2990 return self->Insert(before, info.sizer, proportion, flag, border, data);
2991 else if (info.gotSize)
2992 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
2993 proportion, flag, border, data);
2994 else
2995 return NULL;
2996 }
2997 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2998
2999 wxPyUserData* data = NULL;
3000 bool blocked = wxPyBeginBlockThreads();
3001 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3002 if ( userData && (info.window || info.sizer || info.gotSize) )
3003 data = new wxPyUserData(userData);
3004 wxPyEndBlockThreads(blocked);
3005
3006 // Now call the real Prepend method if a valid item type was found
3007 if ( info.window )
3008 return self->Prepend(info.window, proportion, flag, border, data);
3009 else if ( info.sizer )
3010 return self->Prepend(info.sizer, proportion, flag, border, data);
3011 else if (info.gotSize)
3012 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3013 proportion, flag, border, data);
3014 else
3015 return NULL;
3016 }
3017 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3018 bool blocked = wxPyBeginBlockThreads();
3019 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3020 wxPyEndBlockThreads(blocked);
3021 if ( info.window )
3022 return self->Remove(info.window);
3023 else if ( info.sizer )
3024 return self->Remove(info.sizer);
3025 else if ( info.gotPos )
3026 return self->Remove(info.pos);
3027 else
3028 return false;
3029 }
3030 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3031 bool blocked = wxPyBeginBlockThreads();
3032 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3033 wxPyEndBlockThreads(blocked);
3034 if ( info.window )
3035 return self->Detach(info.window);
3036 else if ( info.sizer )
3037 return self->Detach(info.sizer);
3038 else if ( info.gotPos )
3039 return self->Detach(info.pos);
3040 else
3041 return false;
3042 }
3043 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3044 bool blocked = wxPyBeginBlockThreads();
3045 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3046 wxPyEndBlockThreads(blocked);
3047 if ( info.window )
3048 return self->GetItem(info.window);
3049 else if ( info.sizer )
3050 return self->GetItem(info.sizer);
3051 else if ( info.gotPos )
3052 return self->GetItem(info.pos);
3053 else
3054 return NULL;
3055 }
3056 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3057 bool blocked = wxPyBeginBlockThreads();
3058 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3059 wxPyEndBlockThreads(blocked);
3060 if ( info.window )
3061 self->SetItemMinSize(info.window, size);
3062 else if ( info.sizer )
3063 self->SetItemMinSize(info.sizer, size);
3064 else if ( info.gotPos )
3065 self->SetItemMinSize(info.pos, size);
3066 }
3067 static PyObject *wxSizer_GetChildren(wxSizer *self){
3068 wxSizerItemList& list = self->GetChildren();
3069 return wxPy_ConvertList(&list);
3070 }
3071 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3072 bool blocked = wxPyBeginBlockThreads();
3073 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3074 wxPyEndBlockThreads(blocked);
3075 if ( info.window )
3076 return self->Show(info.window, show, recursive);
3077 else if ( info.sizer )
3078 return self->Show(info.sizer, show, recursive);
3079 else if ( info.gotPos )
3080 return self->Show(info.pos, show);
3081 else
3082 return false;
3083 }
3084 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3085 bool blocked = wxPyBeginBlockThreads();
3086 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3087 wxPyEndBlockThreads(blocked);
3088 if ( info.window )
3089 return self->IsShown(info.window);
3090 else if ( info.sizer )
3091 return self->IsShown(info.sizer);
3092 else if ( info.gotPos )
3093 return self->IsShown(info.pos);
3094 else
3095 return false;
3096 }
3097
3098 // See pyclasses.h
3099 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3100 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3101 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3102
3103
3104
3105
3106 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3107 {
3108 if (source == Py_None) {
3109 **obj = wxGBPosition(-1,-1);
3110 return true;
3111 }
3112 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3113 }
3114
3115 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3116 {
3117 if (source == Py_None) {
3118 **obj = wxGBSpan(-1,-1);
3119 return true;
3120 }
3121 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3122 }
3123
3124
3125 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3126 self->SetRow(row);
3127 self->SetCol(col);
3128 }
3129 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3130 bool blocked = wxPyBeginBlockThreads();
3131 PyObject* tup = PyTuple_New(2);
3132 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3133 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3134 wxPyEndBlockThreads(blocked);
3135 return tup;
3136 }
3137 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3138 self->SetRowspan(rowspan);
3139 self->SetColspan(colspan);
3140 }
3141 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3142 bool blocked = wxPyBeginBlockThreads();
3143 PyObject* tup = PyTuple_New(2);
3144 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3145 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3146 wxPyEndBlockThreads(blocked);
3147 return tup;
3148 }
3149 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3150 wxPyUserData* data = NULL;
3151 if ( userData ) {
3152 bool blocked = wxPyBeginBlockThreads();
3153 data = new wxPyUserData(userData);
3154 wxPyEndBlockThreads(blocked);
3155 }
3156 return new wxGBSizerItem(window, pos, span, flag, border, data);
3157 }
3158 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3159 wxPyUserData* data = NULL;
3160 if ( userData ) {
3161 bool blocked = wxPyBeginBlockThreads();
3162 data = new wxPyUserData(userData);
3163 wxPyEndBlockThreads(blocked);
3164 }
3165 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3166 }
3167 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3168 wxPyUserData* data = NULL;
3169 if ( userData ) {
3170 bool blocked = wxPyBeginBlockThreads();
3171 data = new wxPyUserData(userData);
3172 wxPyEndBlockThreads(blocked);
3173 }
3174 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3175 }
3176 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3177 int row, col;
3178 self->GetEndPos(row, col);
3179 return wxGBPosition(row, col);
3180 }
3181 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3182
3183 wxPyUserData* data = NULL;
3184 bool blocked = wxPyBeginBlockThreads();
3185 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3186 if ( userData && (info.window || info.sizer || info.gotSize) )
3187 data = new wxPyUserData(userData);
3188 wxPyEndBlockThreads(blocked);
3189
3190 // Now call the real Add method if a valid item type was found
3191 if ( info.window )
3192 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3193 else if ( info.sizer )
3194 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3195 else if (info.gotSize)
3196 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3197 pos, span, flag, border, data);
3198 return NULL;
3199 }
3200
3201
3202 #ifdef __cplusplus
3203 extern "C" {
3204 #endif
3205 static int _wrap_EmptyString_set(PyObject *) {
3206 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3207 return 1;
3208 }
3209
3210
3211 static PyObject *_wrap_EmptyString_get(void) {
3212 PyObject *pyobj;
3213
3214 {
3215 #if wxUSE_UNICODE
3216 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3217 #else
3218 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3219 #endif
3220 }
3221 return pyobj;
3222 }
3223
3224
3225 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3226 PyObject *resultobj;
3227 wxObject *arg1 = (wxObject *) 0 ;
3228 wxString result;
3229 PyObject * obj0 = 0 ;
3230 char *kwnames[] = {
3231 (char *) "self", NULL
3232 };
3233
3234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3236 if (SWIG_arg_fail(1)) SWIG_fail;
3237 {
3238 PyThreadState* __tstate = wxPyBeginAllowThreads();
3239 result = wxObject_GetClassName(arg1);
3240
3241 wxPyEndAllowThreads(__tstate);
3242 if (PyErr_Occurred()) SWIG_fail;
3243 }
3244 {
3245 #if wxUSE_UNICODE
3246 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3247 #else
3248 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3249 #endif
3250 }
3251 return resultobj;
3252 fail:
3253 return NULL;
3254 }
3255
3256
3257 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3258 PyObject *resultobj;
3259 wxObject *arg1 = (wxObject *) 0 ;
3260 PyObject * obj0 = 0 ;
3261 char *kwnames[] = {
3262 (char *) "self", NULL
3263 };
3264
3265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3267 if (SWIG_arg_fail(1)) SWIG_fail;
3268 {
3269 PyThreadState* __tstate = wxPyBeginAllowThreads();
3270 wxObject_Destroy(arg1);
3271
3272 wxPyEndAllowThreads(__tstate);
3273 if (PyErr_Occurred()) SWIG_fail;
3274 }
3275 Py_INCREF(Py_None); resultobj = Py_None;
3276 return resultobj;
3277 fail:
3278 return NULL;
3279 }
3280
3281
3282 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3283 PyObject *obj;
3284 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3285 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3286 Py_INCREF(obj);
3287 return Py_BuildValue((char *)"");
3288 }
3289 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3290 PyObject *resultobj;
3291 wxSize *arg1 = (wxSize *) 0 ;
3292 int arg2 ;
3293 PyObject * obj0 = 0 ;
3294 PyObject * obj1 = 0 ;
3295 char *kwnames[] = {
3296 (char *) "self",(char *) "x", NULL
3297 };
3298
3299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3301 if (SWIG_arg_fail(1)) SWIG_fail;
3302 {
3303 arg2 = (int)(SWIG_As_int(obj1));
3304 if (SWIG_arg_fail(2)) SWIG_fail;
3305 }
3306 if (arg1) (arg1)->x = arg2;
3307
3308 Py_INCREF(Py_None); resultobj = Py_None;
3309 return resultobj;
3310 fail:
3311 return NULL;
3312 }
3313
3314
3315 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3316 PyObject *resultobj;
3317 wxSize *arg1 = (wxSize *) 0 ;
3318 int result;
3319 PyObject * obj0 = 0 ;
3320 char *kwnames[] = {
3321 (char *) "self", NULL
3322 };
3323
3324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3326 if (SWIG_arg_fail(1)) SWIG_fail;
3327 result = (int) ((arg1)->x);
3328
3329 {
3330 resultobj = SWIG_From_int((int)(result));
3331 }
3332 return resultobj;
3333 fail:
3334 return NULL;
3335 }
3336
3337
3338 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3339 PyObject *resultobj;
3340 wxSize *arg1 = (wxSize *) 0 ;
3341 int arg2 ;
3342 PyObject * obj0 = 0 ;
3343 PyObject * obj1 = 0 ;
3344 char *kwnames[] = {
3345 (char *) "self",(char *) "y", NULL
3346 };
3347
3348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3350 if (SWIG_arg_fail(1)) SWIG_fail;
3351 {
3352 arg2 = (int)(SWIG_As_int(obj1));
3353 if (SWIG_arg_fail(2)) SWIG_fail;
3354 }
3355 if (arg1) (arg1)->y = arg2;
3356
3357 Py_INCREF(Py_None); resultobj = Py_None;
3358 return resultobj;
3359 fail:
3360 return NULL;
3361 }
3362
3363
3364 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3365 PyObject *resultobj;
3366 wxSize *arg1 = (wxSize *) 0 ;
3367 int result;
3368 PyObject * obj0 = 0 ;
3369 char *kwnames[] = {
3370 (char *) "self", NULL
3371 };
3372
3373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3375 if (SWIG_arg_fail(1)) SWIG_fail;
3376 result = (int) ((arg1)->y);
3377
3378 {
3379 resultobj = SWIG_From_int((int)(result));
3380 }
3381 return resultobj;
3382 fail:
3383 return NULL;
3384 }
3385
3386
3387 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3388 PyObject *resultobj;
3389 int arg1 = (int) 0 ;
3390 int arg2 = (int) 0 ;
3391 wxSize *result;
3392 PyObject * obj0 = 0 ;
3393 PyObject * obj1 = 0 ;
3394 char *kwnames[] = {
3395 (char *) "w",(char *) "h", NULL
3396 };
3397
3398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3399 if (obj0) {
3400 {
3401 arg1 = (int)(SWIG_As_int(obj0));
3402 if (SWIG_arg_fail(1)) SWIG_fail;
3403 }
3404 }
3405 if (obj1) {
3406 {
3407 arg2 = (int)(SWIG_As_int(obj1));
3408 if (SWIG_arg_fail(2)) SWIG_fail;
3409 }
3410 }
3411 {
3412 PyThreadState* __tstate = wxPyBeginAllowThreads();
3413 result = (wxSize *)new wxSize(arg1,arg2);
3414
3415 wxPyEndAllowThreads(__tstate);
3416 if (PyErr_Occurred()) SWIG_fail;
3417 }
3418 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3419 return resultobj;
3420 fail:
3421 return NULL;
3422 }
3423
3424
3425 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3426 PyObject *resultobj;
3427 wxSize *arg1 = (wxSize *) 0 ;
3428 PyObject * obj0 = 0 ;
3429 char *kwnames[] = {
3430 (char *) "self", NULL
3431 };
3432
3433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3435 if (SWIG_arg_fail(1)) SWIG_fail;
3436 {
3437 PyThreadState* __tstate = wxPyBeginAllowThreads();
3438 delete arg1;
3439
3440 wxPyEndAllowThreads(__tstate);
3441 if (PyErr_Occurred()) SWIG_fail;
3442 }
3443 Py_INCREF(Py_None); resultobj = Py_None;
3444 return resultobj;
3445 fail:
3446 return NULL;
3447 }
3448
3449
3450 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3451 PyObject *resultobj;
3452 wxSize *arg1 = (wxSize *) 0 ;
3453 wxSize *arg2 = 0 ;
3454 bool result;
3455 wxSize temp2 ;
3456 PyObject * obj0 = 0 ;
3457 PyObject * obj1 = 0 ;
3458 char *kwnames[] = {
3459 (char *) "self",(char *) "sz", NULL
3460 };
3461
3462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3464 if (SWIG_arg_fail(1)) SWIG_fail;
3465 {
3466 arg2 = &temp2;
3467 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3468 }
3469 {
3470 PyThreadState* __tstate = wxPyBeginAllowThreads();
3471 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3472
3473 wxPyEndAllowThreads(__tstate);
3474 if (PyErr_Occurred()) SWIG_fail;
3475 }
3476 {
3477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3478 }
3479 return resultobj;
3480 fail:
3481 return NULL;
3482 }
3483
3484
3485 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3486 PyObject *resultobj;
3487 wxSize *arg1 = (wxSize *) 0 ;
3488 wxSize *arg2 = 0 ;
3489 bool result;
3490 wxSize temp2 ;
3491 PyObject * obj0 = 0 ;
3492 PyObject * obj1 = 0 ;
3493 char *kwnames[] = {
3494 (char *) "self",(char *) "sz", NULL
3495 };
3496
3497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3499 if (SWIG_arg_fail(1)) SWIG_fail;
3500 {
3501 arg2 = &temp2;
3502 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3503 }
3504 {
3505 PyThreadState* __tstate = wxPyBeginAllowThreads();
3506 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3507
3508 wxPyEndAllowThreads(__tstate);
3509 if (PyErr_Occurred()) SWIG_fail;
3510 }
3511 {
3512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3513 }
3514 return resultobj;
3515 fail:
3516 return NULL;
3517 }
3518
3519
3520 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3521 PyObject *resultobj;
3522 wxSize *arg1 = (wxSize *) 0 ;
3523 wxSize *arg2 = 0 ;
3524 wxSize result;
3525 wxSize temp2 ;
3526 PyObject * obj0 = 0 ;
3527 PyObject * obj1 = 0 ;
3528 char *kwnames[] = {
3529 (char *) "self",(char *) "sz", NULL
3530 };
3531
3532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3534 if (SWIG_arg_fail(1)) SWIG_fail;
3535 {
3536 arg2 = &temp2;
3537 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3538 }
3539 {
3540 PyThreadState* __tstate = wxPyBeginAllowThreads();
3541 result = (arg1)->operator +((wxSize const &)*arg2);
3542
3543 wxPyEndAllowThreads(__tstate);
3544 if (PyErr_Occurred()) SWIG_fail;
3545 }
3546 {
3547 wxSize * resultptr;
3548 resultptr = new wxSize((wxSize &)(result));
3549 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3550 }
3551 return resultobj;
3552 fail:
3553 return NULL;
3554 }
3555
3556
3557 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3558 PyObject *resultobj;
3559 wxSize *arg1 = (wxSize *) 0 ;
3560 wxSize *arg2 = 0 ;
3561 wxSize result;
3562 wxSize temp2 ;
3563 PyObject * obj0 = 0 ;
3564 PyObject * obj1 = 0 ;
3565 char *kwnames[] = {
3566 (char *) "self",(char *) "sz", NULL
3567 };
3568
3569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3571 if (SWIG_arg_fail(1)) SWIG_fail;
3572 {
3573 arg2 = &temp2;
3574 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3575 }
3576 {
3577 PyThreadState* __tstate = wxPyBeginAllowThreads();
3578 result = (arg1)->operator -((wxSize const &)*arg2);
3579
3580 wxPyEndAllowThreads(__tstate);
3581 if (PyErr_Occurred()) SWIG_fail;
3582 }
3583 {
3584 wxSize * resultptr;
3585 resultptr = new wxSize((wxSize &)(result));
3586 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3587 }
3588 return resultobj;
3589 fail:
3590 return NULL;
3591 }
3592
3593
3594 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3595 PyObject *resultobj;
3596 wxSize *arg1 = (wxSize *) 0 ;
3597 wxSize *arg2 = 0 ;
3598 wxSize temp2 ;
3599 PyObject * obj0 = 0 ;
3600 PyObject * obj1 = 0 ;
3601 char *kwnames[] = {
3602 (char *) "self",(char *) "sz", NULL
3603 };
3604
3605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3607 if (SWIG_arg_fail(1)) SWIG_fail;
3608 {
3609 arg2 = &temp2;
3610 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3611 }
3612 {
3613 PyThreadState* __tstate = wxPyBeginAllowThreads();
3614 (arg1)->IncTo((wxSize const &)*arg2);
3615
3616 wxPyEndAllowThreads(__tstate);
3617 if (PyErr_Occurred()) SWIG_fail;
3618 }
3619 Py_INCREF(Py_None); resultobj = Py_None;
3620 return resultobj;
3621 fail:
3622 return NULL;
3623 }
3624
3625
3626 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3627 PyObject *resultobj;
3628 wxSize *arg1 = (wxSize *) 0 ;
3629 wxSize *arg2 = 0 ;
3630 wxSize temp2 ;
3631 PyObject * obj0 = 0 ;
3632 PyObject * obj1 = 0 ;
3633 char *kwnames[] = {
3634 (char *) "self",(char *) "sz", NULL
3635 };
3636
3637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3639 if (SWIG_arg_fail(1)) SWIG_fail;
3640 {
3641 arg2 = &temp2;
3642 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3643 }
3644 {
3645 PyThreadState* __tstate = wxPyBeginAllowThreads();
3646 (arg1)->DecTo((wxSize const &)*arg2);
3647
3648 wxPyEndAllowThreads(__tstate);
3649 if (PyErr_Occurred()) SWIG_fail;
3650 }
3651 Py_INCREF(Py_None); resultobj = Py_None;
3652 return resultobj;
3653 fail:
3654 return NULL;
3655 }
3656
3657
3658 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3659 PyObject *resultobj;
3660 wxSize *arg1 = (wxSize *) 0 ;
3661 int arg2 ;
3662 int arg3 ;
3663 PyObject * obj0 = 0 ;
3664 PyObject * obj1 = 0 ;
3665 PyObject * obj2 = 0 ;
3666 char *kwnames[] = {
3667 (char *) "self",(char *) "w",(char *) "h", NULL
3668 };
3669
3670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3672 if (SWIG_arg_fail(1)) SWIG_fail;
3673 {
3674 arg2 = (int)(SWIG_As_int(obj1));
3675 if (SWIG_arg_fail(2)) SWIG_fail;
3676 }
3677 {
3678 arg3 = (int)(SWIG_As_int(obj2));
3679 if (SWIG_arg_fail(3)) SWIG_fail;
3680 }
3681 {
3682 PyThreadState* __tstate = wxPyBeginAllowThreads();
3683 (arg1)->Set(arg2,arg3);
3684
3685 wxPyEndAllowThreads(__tstate);
3686 if (PyErr_Occurred()) SWIG_fail;
3687 }
3688 Py_INCREF(Py_None); resultobj = Py_None;
3689 return resultobj;
3690 fail:
3691 return NULL;
3692 }
3693
3694
3695 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3696 PyObject *resultobj;
3697 wxSize *arg1 = (wxSize *) 0 ;
3698 int arg2 ;
3699 PyObject * obj0 = 0 ;
3700 PyObject * obj1 = 0 ;
3701 char *kwnames[] = {
3702 (char *) "self",(char *) "w", NULL
3703 };
3704
3705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3707 if (SWIG_arg_fail(1)) SWIG_fail;
3708 {
3709 arg2 = (int)(SWIG_As_int(obj1));
3710 if (SWIG_arg_fail(2)) SWIG_fail;
3711 }
3712 {
3713 PyThreadState* __tstate = wxPyBeginAllowThreads();
3714 (arg1)->SetWidth(arg2);
3715
3716 wxPyEndAllowThreads(__tstate);
3717 if (PyErr_Occurred()) SWIG_fail;
3718 }
3719 Py_INCREF(Py_None); resultobj = Py_None;
3720 return resultobj;
3721 fail:
3722 return NULL;
3723 }
3724
3725
3726 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3727 PyObject *resultobj;
3728 wxSize *arg1 = (wxSize *) 0 ;
3729 int arg2 ;
3730 PyObject * obj0 = 0 ;
3731 PyObject * obj1 = 0 ;
3732 char *kwnames[] = {
3733 (char *) "self",(char *) "h", NULL
3734 };
3735
3736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3738 if (SWIG_arg_fail(1)) SWIG_fail;
3739 {
3740 arg2 = (int)(SWIG_As_int(obj1));
3741 if (SWIG_arg_fail(2)) SWIG_fail;
3742 }
3743 {
3744 PyThreadState* __tstate = wxPyBeginAllowThreads();
3745 (arg1)->SetHeight(arg2);
3746
3747 wxPyEndAllowThreads(__tstate);
3748 if (PyErr_Occurred()) SWIG_fail;
3749 }
3750 Py_INCREF(Py_None); resultobj = Py_None;
3751 return resultobj;
3752 fail:
3753 return NULL;
3754 }
3755
3756
3757 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3758 PyObject *resultobj;
3759 wxSize *arg1 = (wxSize *) 0 ;
3760 int result;
3761 PyObject * obj0 = 0 ;
3762 char *kwnames[] = {
3763 (char *) "self", NULL
3764 };
3765
3766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3768 if (SWIG_arg_fail(1)) SWIG_fail;
3769 {
3770 PyThreadState* __tstate = wxPyBeginAllowThreads();
3771 result = (int)((wxSize const *)arg1)->GetWidth();
3772
3773 wxPyEndAllowThreads(__tstate);
3774 if (PyErr_Occurred()) SWIG_fail;
3775 }
3776 {
3777 resultobj = SWIG_From_int((int)(result));
3778 }
3779 return resultobj;
3780 fail:
3781 return NULL;
3782 }
3783
3784
3785 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3786 PyObject *resultobj;
3787 wxSize *arg1 = (wxSize *) 0 ;
3788 int result;
3789 PyObject * obj0 = 0 ;
3790 char *kwnames[] = {
3791 (char *) "self", NULL
3792 };
3793
3794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3796 if (SWIG_arg_fail(1)) SWIG_fail;
3797 {
3798 PyThreadState* __tstate = wxPyBeginAllowThreads();
3799 result = (int)((wxSize const *)arg1)->GetHeight();
3800
3801 wxPyEndAllowThreads(__tstate);
3802 if (PyErr_Occurred()) SWIG_fail;
3803 }
3804 {
3805 resultobj = SWIG_From_int((int)(result));
3806 }
3807 return resultobj;
3808 fail:
3809 return NULL;
3810 }
3811
3812
3813 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3814 PyObject *resultobj;
3815 wxSize *arg1 = (wxSize *) 0 ;
3816 bool result;
3817 PyObject * obj0 = 0 ;
3818 char *kwnames[] = {
3819 (char *) "self", NULL
3820 };
3821
3822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3824 if (SWIG_arg_fail(1)) SWIG_fail;
3825 {
3826 PyThreadState* __tstate = wxPyBeginAllowThreads();
3827 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3828
3829 wxPyEndAllowThreads(__tstate);
3830 if (PyErr_Occurred()) SWIG_fail;
3831 }
3832 {
3833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3834 }
3835 return resultobj;
3836 fail:
3837 return NULL;
3838 }
3839
3840
3841 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3842 PyObject *resultobj;
3843 wxSize *arg1 = (wxSize *) 0 ;
3844 wxSize *arg2 = 0 ;
3845 wxSize temp2 ;
3846 PyObject * obj0 = 0 ;
3847 PyObject * obj1 = 0 ;
3848 char *kwnames[] = {
3849 (char *) "self",(char *) "size", NULL
3850 };
3851
3852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3854 if (SWIG_arg_fail(1)) SWIG_fail;
3855 {
3856 arg2 = &temp2;
3857 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3858 }
3859 {
3860 PyThreadState* __tstate = wxPyBeginAllowThreads();
3861 (arg1)->SetDefaults((wxSize const &)*arg2);
3862
3863 wxPyEndAllowThreads(__tstate);
3864 if (PyErr_Occurred()) SWIG_fail;
3865 }
3866 Py_INCREF(Py_None); resultobj = Py_None;
3867 return resultobj;
3868 fail:
3869 return NULL;
3870 }
3871
3872
3873 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3874 PyObject *resultobj;
3875 wxSize *arg1 = (wxSize *) 0 ;
3876 PyObject *result;
3877 PyObject * obj0 = 0 ;
3878 char *kwnames[] = {
3879 (char *) "self", NULL
3880 };
3881
3882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3884 if (SWIG_arg_fail(1)) SWIG_fail;
3885 {
3886 PyThreadState* __tstate = wxPyBeginAllowThreads();
3887 result = (PyObject *)wxSize_Get(arg1);
3888
3889 wxPyEndAllowThreads(__tstate);
3890 if (PyErr_Occurred()) SWIG_fail;
3891 }
3892 resultobj = result;
3893 return resultobj;
3894 fail:
3895 return NULL;
3896 }
3897
3898
3899 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3900 PyObject *obj;
3901 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3902 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3903 Py_INCREF(obj);
3904 return Py_BuildValue((char *)"");
3905 }
3906 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3907 PyObject *resultobj;
3908 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3909 double arg2 ;
3910 PyObject * obj0 = 0 ;
3911 PyObject * obj1 = 0 ;
3912 char *kwnames[] = {
3913 (char *) "self",(char *) "x", NULL
3914 };
3915
3916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3918 if (SWIG_arg_fail(1)) SWIG_fail;
3919 {
3920 arg2 = (double)(SWIG_As_double(obj1));
3921 if (SWIG_arg_fail(2)) SWIG_fail;
3922 }
3923 if (arg1) (arg1)->x = arg2;
3924
3925 Py_INCREF(Py_None); resultobj = Py_None;
3926 return resultobj;
3927 fail:
3928 return NULL;
3929 }
3930
3931
3932 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3933 PyObject *resultobj;
3934 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3935 double result;
3936 PyObject * obj0 = 0 ;
3937 char *kwnames[] = {
3938 (char *) "self", NULL
3939 };
3940
3941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3943 if (SWIG_arg_fail(1)) SWIG_fail;
3944 result = (double) ((arg1)->x);
3945
3946 {
3947 resultobj = SWIG_From_double((double)(result));
3948 }
3949 return resultobj;
3950 fail:
3951 return NULL;
3952 }
3953
3954
3955 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3956 PyObject *resultobj;
3957 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3958 double arg2 ;
3959 PyObject * obj0 = 0 ;
3960 PyObject * obj1 = 0 ;
3961 char *kwnames[] = {
3962 (char *) "self",(char *) "y", NULL
3963 };
3964
3965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3967 if (SWIG_arg_fail(1)) SWIG_fail;
3968 {
3969 arg2 = (double)(SWIG_As_double(obj1));
3970 if (SWIG_arg_fail(2)) SWIG_fail;
3971 }
3972 if (arg1) (arg1)->y = arg2;
3973
3974 Py_INCREF(Py_None); resultobj = Py_None;
3975 return resultobj;
3976 fail:
3977 return NULL;
3978 }
3979
3980
3981 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
3982 PyObject *resultobj;
3983 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3984 double result;
3985 PyObject * obj0 = 0 ;
3986 char *kwnames[] = {
3987 (char *) "self", NULL
3988 };
3989
3990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
3991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3992 if (SWIG_arg_fail(1)) SWIG_fail;
3993 result = (double) ((arg1)->y);
3994
3995 {
3996 resultobj = SWIG_From_double((double)(result));
3997 }
3998 return resultobj;
3999 fail:
4000 return NULL;
4001 }
4002
4003
4004 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4005 PyObject *resultobj;
4006 double arg1 = (double) 0.0 ;
4007 double arg2 = (double) 0.0 ;
4008 wxRealPoint *result;
4009 PyObject * obj0 = 0 ;
4010 PyObject * obj1 = 0 ;
4011 char *kwnames[] = {
4012 (char *) "x",(char *) "y", NULL
4013 };
4014
4015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4016 if (obj0) {
4017 {
4018 arg1 = (double)(SWIG_As_double(obj0));
4019 if (SWIG_arg_fail(1)) SWIG_fail;
4020 }
4021 }
4022 if (obj1) {
4023 {
4024 arg2 = (double)(SWIG_As_double(obj1));
4025 if (SWIG_arg_fail(2)) SWIG_fail;
4026 }
4027 }
4028 {
4029 PyThreadState* __tstate = wxPyBeginAllowThreads();
4030 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4031
4032 wxPyEndAllowThreads(__tstate);
4033 if (PyErr_Occurred()) SWIG_fail;
4034 }
4035 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4036 return resultobj;
4037 fail:
4038 return NULL;
4039 }
4040
4041
4042 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4043 PyObject *resultobj;
4044 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4045 PyObject * obj0 = 0 ;
4046 char *kwnames[] = {
4047 (char *) "self", NULL
4048 };
4049
4050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4052 if (SWIG_arg_fail(1)) SWIG_fail;
4053 {
4054 PyThreadState* __tstate = wxPyBeginAllowThreads();
4055 delete arg1;
4056
4057 wxPyEndAllowThreads(__tstate);
4058 if (PyErr_Occurred()) SWIG_fail;
4059 }
4060 Py_INCREF(Py_None); resultobj = Py_None;
4061 return resultobj;
4062 fail:
4063 return NULL;
4064 }
4065
4066
4067 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4068 PyObject *resultobj;
4069 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4070 wxRealPoint *arg2 = 0 ;
4071 bool result;
4072 wxRealPoint temp2 ;
4073 PyObject * obj0 = 0 ;
4074 PyObject * obj1 = 0 ;
4075 char *kwnames[] = {
4076 (char *) "self",(char *) "pt", NULL
4077 };
4078
4079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4081 if (SWIG_arg_fail(1)) SWIG_fail;
4082 {
4083 arg2 = &temp2;
4084 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4085 }
4086 {
4087 PyThreadState* __tstate = wxPyBeginAllowThreads();
4088 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4089
4090 wxPyEndAllowThreads(__tstate);
4091 if (PyErr_Occurred()) SWIG_fail;
4092 }
4093 {
4094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4095 }
4096 return resultobj;
4097 fail:
4098 return NULL;
4099 }
4100
4101
4102 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4103 PyObject *resultobj;
4104 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4105 wxRealPoint *arg2 = 0 ;
4106 bool result;
4107 wxRealPoint temp2 ;
4108 PyObject * obj0 = 0 ;
4109 PyObject * obj1 = 0 ;
4110 char *kwnames[] = {
4111 (char *) "self",(char *) "pt", NULL
4112 };
4113
4114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4116 if (SWIG_arg_fail(1)) SWIG_fail;
4117 {
4118 arg2 = &temp2;
4119 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4120 }
4121 {
4122 PyThreadState* __tstate = wxPyBeginAllowThreads();
4123 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4124
4125 wxPyEndAllowThreads(__tstate);
4126 if (PyErr_Occurred()) SWIG_fail;
4127 }
4128 {
4129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4130 }
4131 return resultobj;
4132 fail:
4133 return NULL;
4134 }
4135
4136
4137 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4138 PyObject *resultobj;
4139 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4140 wxRealPoint *arg2 = 0 ;
4141 wxRealPoint result;
4142 wxRealPoint temp2 ;
4143 PyObject * obj0 = 0 ;
4144 PyObject * obj1 = 0 ;
4145 char *kwnames[] = {
4146 (char *) "self",(char *) "pt", NULL
4147 };
4148
4149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4151 if (SWIG_arg_fail(1)) SWIG_fail;
4152 {
4153 arg2 = &temp2;
4154 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4155 }
4156 {
4157 PyThreadState* __tstate = wxPyBeginAllowThreads();
4158 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4159
4160 wxPyEndAllowThreads(__tstate);
4161 if (PyErr_Occurred()) SWIG_fail;
4162 }
4163 {
4164 wxRealPoint * resultptr;
4165 resultptr = new wxRealPoint((wxRealPoint &)(result));
4166 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4167 }
4168 return resultobj;
4169 fail:
4170 return NULL;
4171 }
4172
4173
4174 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4175 PyObject *resultobj;
4176 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4177 wxRealPoint *arg2 = 0 ;
4178 wxRealPoint result;
4179 wxRealPoint temp2 ;
4180 PyObject * obj0 = 0 ;
4181 PyObject * obj1 = 0 ;
4182 char *kwnames[] = {
4183 (char *) "self",(char *) "pt", NULL
4184 };
4185
4186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4188 if (SWIG_arg_fail(1)) SWIG_fail;
4189 {
4190 arg2 = &temp2;
4191 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4192 }
4193 {
4194 PyThreadState* __tstate = wxPyBeginAllowThreads();
4195 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4196
4197 wxPyEndAllowThreads(__tstate);
4198 if (PyErr_Occurred()) SWIG_fail;
4199 }
4200 {
4201 wxRealPoint * resultptr;
4202 resultptr = new wxRealPoint((wxRealPoint &)(result));
4203 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4204 }
4205 return resultobj;
4206 fail:
4207 return NULL;
4208 }
4209
4210
4211 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4212 PyObject *resultobj;
4213 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4214 double arg2 ;
4215 double arg3 ;
4216 PyObject * obj0 = 0 ;
4217 PyObject * obj1 = 0 ;
4218 PyObject * obj2 = 0 ;
4219 char *kwnames[] = {
4220 (char *) "self",(char *) "x",(char *) "y", NULL
4221 };
4222
4223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4225 if (SWIG_arg_fail(1)) SWIG_fail;
4226 {
4227 arg2 = (double)(SWIG_As_double(obj1));
4228 if (SWIG_arg_fail(2)) SWIG_fail;
4229 }
4230 {
4231 arg3 = (double)(SWIG_As_double(obj2));
4232 if (SWIG_arg_fail(3)) SWIG_fail;
4233 }
4234 {
4235 PyThreadState* __tstate = wxPyBeginAllowThreads();
4236 wxRealPoint_Set(arg1,arg2,arg3);
4237
4238 wxPyEndAllowThreads(__tstate);
4239 if (PyErr_Occurred()) SWIG_fail;
4240 }
4241 Py_INCREF(Py_None); resultobj = Py_None;
4242 return resultobj;
4243 fail:
4244 return NULL;
4245 }
4246
4247
4248 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4249 PyObject *resultobj;
4250 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4251 PyObject *result;
4252 PyObject * obj0 = 0 ;
4253 char *kwnames[] = {
4254 (char *) "self", NULL
4255 };
4256
4257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4259 if (SWIG_arg_fail(1)) SWIG_fail;
4260 {
4261 PyThreadState* __tstate = wxPyBeginAllowThreads();
4262 result = (PyObject *)wxRealPoint_Get(arg1);
4263
4264 wxPyEndAllowThreads(__tstate);
4265 if (PyErr_Occurred()) SWIG_fail;
4266 }
4267 resultobj = result;
4268 return resultobj;
4269 fail:
4270 return NULL;
4271 }
4272
4273
4274 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4275 PyObject *obj;
4276 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4277 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4278 Py_INCREF(obj);
4279 return Py_BuildValue((char *)"");
4280 }
4281 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4282 PyObject *resultobj;
4283 wxPoint *arg1 = (wxPoint *) 0 ;
4284 int arg2 ;
4285 PyObject * obj0 = 0 ;
4286 PyObject * obj1 = 0 ;
4287 char *kwnames[] = {
4288 (char *) "self",(char *) "x", NULL
4289 };
4290
4291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4293 if (SWIG_arg_fail(1)) SWIG_fail;
4294 {
4295 arg2 = (int)(SWIG_As_int(obj1));
4296 if (SWIG_arg_fail(2)) SWIG_fail;
4297 }
4298 if (arg1) (arg1)->x = arg2;
4299
4300 Py_INCREF(Py_None); resultobj = Py_None;
4301 return resultobj;
4302 fail:
4303 return NULL;
4304 }
4305
4306
4307 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4308 PyObject *resultobj;
4309 wxPoint *arg1 = (wxPoint *) 0 ;
4310 int result;
4311 PyObject * obj0 = 0 ;
4312 char *kwnames[] = {
4313 (char *) "self", NULL
4314 };
4315
4316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4318 if (SWIG_arg_fail(1)) SWIG_fail;
4319 result = (int) ((arg1)->x);
4320
4321 {
4322 resultobj = SWIG_From_int((int)(result));
4323 }
4324 return resultobj;
4325 fail:
4326 return NULL;
4327 }
4328
4329
4330 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4331 PyObject *resultobj;
4332 wxPoint *arg1 = (wxPoint *) 0 ;
4333 int arg2 ;
4334 PyObject * obj0 = 0 ;
4335 PyObject * obj1 = 0 ;
4336 char *kwnames[] = {
4337 (char *) "self",(char *) "y", NULL
4338 };
4339
4340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4342 if (SWIG_arg_fail(1)) SWIG_fail;
4343 {
4344 arg2 = (int)(SWIG_As_int(obj1));
4345 if (SWIG_arg_fail(2)) SWIG_fail;
4346 }
4347 if (arg1) (arg1)->y = arg2;
4348
4349 Py_INCREF(Py_None); resultobj = Py_None;
4350 return resultobj;
4351 fail:
4352 return NULL;
4353 }
4354
4355
4356 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4357 PyObject *resultobj;
4358 wxPoint *arg1 = (wxPoint *) 0 ;
4359 int result;
4360 PyObject * obj0 = 0 ;
4361 char *kwnames[] = {
4362 (char *) "self", NULL
4363 };
4364
4365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4367 if (SWIG_arg_fail(1)) SWIG_fail;
4368 result = (int) ((arg1)->y);
4369
4370 {
4371 resultobj = SWIG_From_int((int)(result));
4372 }
4373 return resultobj;
4374 fail:
4375 return NULL;
4376 }
4377
4378
4379 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4380 PyObject *resultobj;
4381 int arg1 = (int) 0 ;
4382 int arg2 = (int) 0 ;
4383 wxPoint *result;
4384 PyObject * obj0 = 0 ;
4385 PyObject * obj1 = 0 ;
4386 char *kwnames[] = {
4387 (char *) "x",(char *) "y", NULL
4388 };
4389
4390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4391 if (obj0) {
4392 {
4393 arg1 = (int)(SWIG_As_int(obj0));
4394 if (SWIG_arg_fail(1)) SWIG_fail;
4395 }
4396 }
4397 if (obj1) {
4398 {
4399 arg2 = (int)(SWIG_As_int(obj1));
4400 if (SWIG_arg_fail(2)) SWIG_fail;
4401 }
4402 }
4403 {
4404 PyThreadState* __tstate = wxPyBeginAllowThreads();
4405 result = (wxPoint *)new wxPoint(arg1,arg2);
4406
4407 wxPyEndAllowThreads(__tstate);
4408 if (PyErr_Occurred()) SWIG_fail;
4409 }
4410 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4411 return resultobj;
4412 fail:
4413 return NULL;
4414 }
4415
4416
4417 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4418 PyObject *resultobj;
4419 wxPoint *arg1 = (wxPoint *) 0 ;
4420 PyObject * obj0 = 0 ;
4421 char *kwnames[] = {
4422 (char *) "self", NULL
4423 };
4424
4425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4427 if (SWIG_arg_fail(1)) SWIG_fail;
4428 {
4429 PyThreadState* __tstate = wxPyBeginAllowThreads();
4430 delete arg1;
4431
4432 wxPyEndAllowThreads(__tstate);
4433 if (PyErr_Occurred()) SWIG_fail;
4434 }
4435 Py_INCREF(Py_None); resultobj = Py_None;
4436 return resultobj;
4437 fail:
4438 return NULL;
4439 }
4440
4441
4442 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4443 PyObject *resultobj;
4444 wxPoint *arg1 = (wxPoint *) 0 ;
4445 wxPoint *arg2 = 0 ;
4446 bool result;
4447 wxPoint temp2 ;
4448 PyObject * obj0 = 0 ;
4449 PyObject * obj1 = 0 ;
4450 char *kwnames[] = {
4451 (char *) "self",(char *) "pt", NULL
4452 };
4453
4454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4456 if (SWIG_arg_fail(1)) SWIG_fail;
4457 {
4458 arg2 = &temp2;
4459 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4460 }
4461 {
4462 PyThreadState* __tstate = wxPyBeginAllowThreads();
4463 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4464
4465 wxPyEndAllowThreads(__tstate);
4466 if (PyErr_Occurred()) SWIG_fail;
4467 }
4468 {
4469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4470 }
4471 return resultobj;
4472 fail:
4473 return NULL;
4474 }
4475
4476
4477 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4478 PyObject *resultobj;
4479 wxPoint *arg1 = (wxPoint *) 0 ;
4480 wxPoint *arg2 = 0 ;
4481 bool result;
4482 wxPoint temp2 ;
4483 PyObject * obj0 = 0 ;
4484 PyObject * obj1 = 0 ;
4485 char *kwnames[] = {
4486 (char *) "self",(char *) "pt", NULL
4487 };
4488
4489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4491 if (SWIG_arg_fail(1)) SWIG_fail;
4492 {
4493 arg2 = &temp2;
4494 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4495 }
4496 {
4497 PyThreadState* __tstate = wxPyBeginAllowThreads();
4498 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4499
4500 wxPyEndAllowThreads(__tstate);
4501 if (PyErr_Occurred()) SWIG_fail;
4502 }
4503 {
4504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4505 }
4506 return resultobj;
4507 fail:
4508 return NULL;
4509 }
4510
4511
4512 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4513 PyObject *resultobj;
4514 wxPoint *arg1 = (wxPoint *) 0 ;
4515 wxPoint *arg2 = 0 ;
4516 wxPoint result;
4517 wxPoint temp2 ;
4518 PyObject * obj0 = 0 ;
4519 PyObject * obj1 = 0 ;
4520 char *kwnames[] = {
4521 (char *) "self",(char *) "pt", NULL
4522 };
4523
4524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4526 if (SWIG_arg_fail(1)) SWIG_fail;
4527 {
4528 arg2 = &temp2;
4529 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4530 }
4531 {
4532 PyThreadState* __tstate = wxPyBeginAllowThreads();
4533 result = (arg1)->operator +((wxPoint const &)*arg2);
4534
4535 wxPyEndAllowThreads(__tstate);
4536 if (PyErr_Occurred()) SWIG_fail;
4537 }
4538 {
4539 wxPoint * resultptr;
4540 resultptr = new wxPoint((wxPoint &)(result));
4541 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4542 }
4543 return resultobj;
4544 fail:
4545 return NULL;
4546 }
4547
4548
4549 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4550 PyObject *resultobj;
4551 wxPoint *arg1 = (wxPoint *) 0 ;
4552 wxPoint *arg2 = 0 ;
4553 wxPoint result;
4554 wxPoint temp2 ;
4555 PyObject * obj0 = 0 ;
4556 PyObject * obj1 = 0 ;
4557 char *kwnames[] = {
4558 (char *) "self",(char *) "pt", NULL
4559 };
4560
4561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4563 if (SWIG_arg_fail(1)) SWIG_fail;
4564 {
4565 arg2 = &temp2;
4566 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4567 }
4568 {
4569 PyThreadState* __tstate = wxPyBeginAllowThreads();
4570 result = (arg1)->operator -((wxPoint const &)*arg2);
4571
4572 wxPyEndAllowThreads(__tstate);
4573 if (PyErr_Occurred()) SWIG_fail;
4574 }
4575 {
4576 wxPoint * resultptr;
4577 resultptr = new wxPoint((wxPoint &)(result));
4578 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4579 }
4580 return resultobj;
4581 fail:
4582 return NULL;
4583 }
4584
4585
4586 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4587 PyObject *resultobj;
4588 wxPoint *arg1 = (wxPoint *) 0 ;
4589 wxPoint *arg2 = 0 ;
4590 wxPoint *result;
4591 wxPoint temp2 ;
4592 PyObject * obj0 = 0 ;
4593 PyObject * obj1 = 0 ;
4594 char *kwnames[] = {
4595 (char *) "self",(char *) "pt", NULL
4596 };
4597
4598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4600 if (SWIG_arg_fail(1)) SWIG_fail;
4601 {
4602 arg2 = &temp2;
4603 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4604 }
4605 {
4606 PyThreadState* __tstate = wxPyBeginAllowThreads();
4607 {
4608 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4609 result = (wxPoint *) &_result_ref;
4610 }
4611
4612 wxPyEndAllowThreads(__tstate);
4613 if (PyErr_Occurred()) SWIG_fail;
4614 }
4615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4616 return resultobj;
4617 fail:
4618 return NULL;
4619 }
4620
4621
4622 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4623 PyObject *resultobj;
4624 wxPoint *arg1 = (wxPoint *) 0 ;
4625 wxPoint *arg2 = 0 ;
4626 wxPoint *result;
4627 wxPoint temp2 ;
4628 PyObject * obj0 = 0 ;
4629 PyObject * obj1 = 0 ;
4630 char *kwnames[] = {
4631 (char *) "self",(char *) "pt", NULL
4632 };
4633
4634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4636 if (SWIG_arg_fail(1)) SWIG_fail;
4637 {
4638 arg2 = &temp2;
4639 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4640 }
4641 {
4642 PyThreadState* __tstate = wxPyBeginAllowThreads();
4643 {
4644 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4645 result = (wxPoint *) &_result_ref;
4646 }
4647
4648 wxPyEndAllowThreads(__tstate);
4649 if (PyErr_Occurred()) SWIG_fail;
4650 }
4651 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4652 return resultobj;
4653 fail:
4654 return NULL;
4655 }
4656
4657
4658 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4659 PyObject *resultobj;
4660 wxPoint *arg1 = (wxPoint *) 0 ;
4661 long arg2 ;
4662 long arg3 ;
4663 PyObject * obj0 = 0 ;
4664 PyObject * obj1 = 0 ;
4665 PyObject * obj2 = 0 ;
4666 char *kwnames[] = {
4667 (char *) "self",(char *) "x",(char *) "y", NULL
4668 };
4669
4670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4672 if (SWIG_arg_fail(1)) SWIG_fail;
4673 {
4674 arg2 = (long)(SWIG_As_long(obj1));
4675 if (SWIG_arg_fail(2)) SWIG_fail;
4676 }
4677 {
4678 arg3 = (long)(SWIG_As_long(obj2));
4679 if (SWIG_arg_fail(3)) SWIG_fail;
4680 }
4681 {
4682 PyThreadState* __tstate = wxPyBeginAllowThreads();
4683 wxPoint_Set(arg1,arg2,arg3);
4684
4685 wxPyEndAllowThreads(__tstate);
4686 if (PyErr_Occurred()) SWIG_fail;
4687 }
4688 Py_INCREF(Py_None); resultobj = Py_None;
4689 return resultobj;
4690 fail:
4691 return NULL;
4692 }
4693
4694
4695 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4696 PyObject *resultobj;
4697 wxPoint *arg1 = (wxPoint *) 0 ;
4698 PyObject *result;
4699 PyObject * obj0 = 0 ;
4700 char *kwnames[] = {
4701 (char *) "self", NULL
4702 };
4703
4704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4706 if (SWIG_arg_fail(1)) SWIG_fail;
4707 {
4708 PyThreadState* __tstate = wxPyBeginAllowThreads();
4709 result = (PyObject *)wxPoint_Get(arg1);
4710
4711 wxPyEndAllowThreads(__tstate);
4712 if (PyErr_Occurred()) SWIG_fail;
4713 }
4714 resultobj = result;
4715 return resultobj;
4716 fail:
4717 return NULL;
4718 }
4719
4720
4721 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4722 PyObject *obj;
4723 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4724 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4725 Py_INCREF(obj);
4726 return Py_BuildValue((char *)"");
4727 }
4728 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4729 PyObject *resultobj;
4730 int arg1 = (int) 0 ;
4731 int arg2 = (int) 0 ;
4732 int arg3 = (int) 0 ;
4733 int arg4 = (int) 0 ;
4734 wxRect *result;
4735 PyObject * obj0 = 0 ;
4736 PyObject * obj1 = 0 ;
4737 PyObject * obj2 = 0 ;
4738 PyObject * obj3 = 0 ;
4739 char *kwnames[] = {
4740 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4741 };
4742
4743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4744 if (obj0) {
4745 {
4746 arg1 = (int)(SWIG_As_int(obj0));
4747 if (SWIG_arg_fail(1)) SWIG_fail;
4748 }
4749 }
4750 if (obj1) {
4751 {
4752 arg2 = (int)(SWIG_As_int(obj1));
4753 if (SWIG_arg_fail(2)) SWIG_fail;
4754 }
4755 }
4756 if (obj2) {
4757 {
4758 arg3 = (int)(SWIG_As_int(obj2));
4759 if (SWIG_arg_fail(3)) SWIG_fail;
4760 }
4761 }
4762 if (obj3) {
4763 {
4764 arg4 = (int)(SWIG_As_int(obj3));
4765 if (SWIG_arg_fail(4)) SWIG_fail;
4766 }
4767 }
4768 {
4769 PyThreadState* __tstate = wxPyBeginAllowThreads();
4770 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4771
4772 wxPyEndAllowThreads(__tstate);
4773 if (PyErr_Occurred()) SWIG_fail;
4774 }
4775 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4776 return resultobj;
4777 fail:
4778 return NULL;
4779 }
4780
4781
4782 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4783 PyObject *resultobj;
4784 wxPoint *arg1 = 0 ;
4785 wxPoint *arg2 = 0 ;
4786 wxRect *result;
4787 wxPoint temp1 ;
4788 wxPoint temp2 ;
4789 PyObject * obj0 = 0 ;
4790 PyObject * obj1 = 0 ;
4791 char *kwnames[] = {
4792 (char *) "topLeft",(char *) "bottomRight", NULL
4793 };
4794
4795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4796 {
4797 arg1 = &temp1;
4798 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4799 }
4800 {
4801 arg2 = &temp2;
4802 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4803 }
4804 {
4805 PyThreadState* __tstate = wxPyBeginAllowThreads();
4806 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4807
4808 wxPyEndAllowThreads(__tstate);
4809 if (PyErr_Occurred()) SWIG_fail;
4810 }
4811 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4812 return resultobj;
4813 fail:
4814 return NULL;
4815 }
4816
4817
4818 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4819 PyObject *resultobj;
4820 wxPoint *arg1 = 0 ;
4821 wxSize *arg2 = 0 ;
4822 wxRect *result;
4823 wxPoint temp1 ;
4824 wxSize temp2 ;
4825 PyObject * obj0 = 0 ;
4826 PyObject * obj1 = 0 ;
4827 char *kwnames[] = {
4828 (char *) "pos",(char *) "size", NULL
4829 };
4830
4831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4832 {
4833 arg1 = &temp1;
4834 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4835 }
4836 {
4837 arg2 = &temp2;
4838 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4839 }
4840 {
4841 PyThreadState* __tstate = wxPyBeginAllowThreads();
4842 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4843
4844 wxPyEndAllowThreads(__tstate);
4845 if (PyErr_Occurred()) SWIG_fail;
4846 }
4847 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4848 return resultobj;
4849 fail:
4850 return NULL;
4851 }
4852
4853
4854 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4855 PyObject *resultobj;
4856 wxSize *arg1 = 0 ;
4857 wxRect *result;
4858 wxSize temp1 ;
4859 PyObject * obj0 = 0 ;
4860 char *kwnames[] = {
4861 (char *) "size", NULL
4862 };
4863
4864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4865 {
4866 arg1 = &temp1;
4867 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4868 }
4869 {
4870 PyThreadState* __tstate = wxPyBeginAllowThreads();
4871 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4872
4873 wxPyEndAllowThreads(__tstate);
4874 if (PyErr_Occurred()) SWIG_fail;
4875 }
4876 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4877 return resultobj;
4878 fail:
4879 return NULL;
4880 }
4881
4882
4883 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4884 PyObject *resultobj;
4885 wxRect *arg1 = (wxRect *) 0 ;
4886 PyObject * obj0 = 0 ;
4887 char *kwnames[] = {
4888 (char *) "self", NULL
4889 };
4890
4891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4893 if (SWIG_arg_fail(1)) SWIG_fail;
4894 {
4895 PyThreadState* __tstate = wxPyBeginAllowThreads();
4896 delete arg1;
4897
4898 wxPyEndAllowThreads(__tstate);
4899 if (PyErr_Occurred()) SWIG_fail;
4900 }
4901 Py_INCREF(Py_None); resultobj = Py_None;
4902 return resultobj;
4903 fail:
4904 return NULL;
4905 }
4906
4907
4908 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4909 PyObject *resultobj;
4910 wxRect *arg1 = (wxRect *) 0 ;
4911 int result;
4912 PyObject * obj0 = 0 ;
4913 char *kwnames[] = {
4914 (char *) "self", NULL
4915 };
4916
4917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4919 if (SWIG_arg_fail(1)) SWIG_fail;
4920 {
4921 PyThreadState* __tstate = wxPyBeginAllowThreads();
4922 result = (int)((wxRect const *)arg1)->GetX();
4923
4924 wxPyEndAllowThreads(__tstate);
4925 if (PyErr_Occurred()) SWIG_fail;
4926 }
4927 {
4928 resultobj = SWIG_From_int((int)(result));
4929 }
4930 return resultobj;
4931 fail:
4932 return NULL;
4933 }
4934
4935
4936 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4937 PyObject *resultobj;
4938 wxRect *arg1 = (wxRect *) 0 ;
4939 int arg2 ;
4940 PyObject * obj0 = 0 ;
4941 PyObject * obj1 = 0 ;
4942 char *kwnames[] = {
4943 (char *) "self",(char *) "x", NULL
4944 };
4945
4946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4948 if (SWIG_arg_fail(1)) SWIG_fail;
4949 {
4950 arg2 = (int)(SWIG_As_int(obj1));
4951 if (SWIG_arg_fail(2)) SWIG_fail;
4952 }
4953 {
4954 PyThreadState* __tstate = wxPyBeginAllowThreads();
4955 (arg1)->SetX(arg2);
4956
4957 wxPyEndAllowThreads(__tstate);
4958 if (PyErr_Occurred()) SWIG_fail;
4959 }
4960 Py_INCREF(Py_None); resultobj = Py_None;
4961 return resultobj;
4962 fail:
4963 return NULL;
4964 }
4965
4966
4967 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4968 PyObject *resultobj;
4969 wxRect *arg1 = (wxRect *) 0 ;
4970 int result;
4971 PyObject * obj0 = 0 ;
4972 char *kwnames[] = {
4973 (char *) "self", NULL
4974 };
4975
4976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
4977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4978 if (SWIG_arg_fail(1)) SWIG_fail;
4979 {
4980 PyThreadState* __tstate = wxPyBeginAllowThreads();
4981 result = (int)(arg1)->GetY();
4982
4983 wxPyEndAllowThreads(__tstate);
4984 if (PyErr_Occurred()) SWIG_fail;
4985 }
4986 {
4987 resultobj = SWIG_From_int((int)(result));
4988 }
4989 return resultobj;
4990 fail:
4991 return NULL;
4992 }
4993
4994
4995 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
4996 PyObject *resultobj;
4997 wxRect *arg1 = (wxRect *) 0 ;
4998 int arg2 ;
4999 PyObject * obj0 = 0 ;
5000 PyObject * obj1 = 0 ;
5001 char *kwnames[] = {
5002 (char *) "self",(char *) "y", NULL
5003 };
5004
5005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5007 if (SWIG_arg_fail(1)) SWIG_fail;
5008 {
5009 arg2 = (int)(SWIG_As_int(obj1));
5010 if (SWIG_arg_fail(2)) SWIG_fail;
5011 }
5012 {
5013 PyThreadState* __tstate = wxPyBeginAllowThreads();
5014 (arg1)->SetY(arg2);
5015
5016 wxPyEndAllowThreads(__tstate);
5017 if (PyErr_Occurred()) SWIG_fail;
5018 }
5019 Py_INCREF(Py_None); resultobj = Py_None;
5020 return resultobj;
5021 fail:
5022 return NULL;
5023 }
5024
5025
5026 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5027 PyObject *resultobj;
5028 wxRect *arg1 = (wxRect *) 0 ;
5029 int result;
5030 PyObject * obj0 = 0 ;
5031 char *kwnames[] = {
5032 (char *) "self", NULL
5033 };
5034
5035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5037 if (SWIG_arg_fail(1)) SWIG_fail;
5038 {
5039 PyThreadState* __tstate = wxPyBeginAllowThreads();
5040 result = (int)((wxRect const *)arg1)->GetWidth();
5041
5042 wxPyEndAllowThreads(__tstate);
5043 if (PyErr_Occurred()) SWIG_fail;
5044 }
5045 {
5046 resultobj = SWIG_From_int((int)(result));
5047 }
5048 return resultobj;
5049 fail:
5050 return NULL;
5051 }
5052
5053
5054 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5055 PyObject *resultobj;
5056 wxRect *arg1 = (wxRect *) 0 ;
5057 int arg2 ;
5058 PyObject * obj0 = 0 ;
5059 PyObject * obj1 = 0 ;
5060 char *kwnames[] = {
5061 (char *) "self",(char *) "w", NULL
5062 };
5063
5064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5066 if (SWIG_arg_fail(1)) SWIG_fail;
5067 {
5068 arg2 = (int)(SWIG_As_int(obj1));
5069 if (SWIG_arg_fail(2)) SWIG_fail;
5070 }
5071 {
5072 PyThreadState* __tstate = wxPyBeginAllowThreads();
5073 (arg1)->SetWidth(arg2);
5074
5075 wxPyEndAllowThreads(__tstate);
5076 if (PyErr_Occurred()) SWIG_fail;
5077 }
5078 Py_INCREF(Py_None); resultobj = Py_None;
5079 return resultobj;
5080 fail:
5081 return NULL;
5082 }
5083
5084
5085 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5086 PyObject *resultobj;
5087 wxRect *arg1 = (wxRect *) 0 ;
5088 int result;
5089 PyObject * obj0 = 0 ;
5090 char *kwnames[] = {
5091 (char *) "self", NULL
5092 };
5093
5094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5096 if (SWIG_arg_fail(1)) SWIG_fail;
5097 {
5098 PyThreadState* __tstate = wxPyBeginAllowThreads();
5099 result = (int)((wxRect const *)arg1)->GetHeight();
5100
5101 wxPyEndAllowThreads(__tstate);
5102 if (PyErr_Occurred()) SWIG_fail;
5103 }
5104 {
5105 resultobj = SWIG_From_int((int)(result));
5106 }
5107 return resultobj;
5108 fail:
5109 return NULL;
5110 }
5111
5112
5113 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5114 PyObject *resultobj;
5115 wxRect *arg1 = (wxRect *) 0 ;
5116 int arg2 ;
5117 PyObject * obj0 = 0 ;
5118 PyObject * obj1 = 0 ;
5119 char *kwnames[] = {
5120 (char *) "self",(char *) "h", NULL
5121 };
5122
5123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5125 if (SWIG_arg_fail(1)) SWIG_fail;
5126 {
5127 arg2 = (int)(SWIG_As_int(obj1));
5128 if (SWIG_arg_fail(2)) SWIG_fail;
5129 }
5130 {
5131 PyThreadState* __tstate = wxPyBeginAllowThreads();
5132 (arg1)->SetHeight(arg2);
5133
5134 wxPyEndAllowThreads(__tstate);
5135 if (PyErr_Occurred()) SWIG_fail;
5136 }
5137 Py_INCREF(Py_None); resultobj = Py_None;
5138 return resultobj;
5139 fail:
5140 return NULL;
5141 }
5142
5143
5144 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5145 PyObject *resultobj;
5146 wxRect *arg1 = (wxRect *) 0 ;
5147 wxPoint result;
5148 PyObject * obj0 = 0 ;
5149 char *kwnames[] = {
5150 (char *) "self", NULL
5151 };
5152
5153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5155 if (SWIG_arg_fail(1)) SWIG_fail;
5156 {
5157 PyThreadState* __tstate = wxPyBeginAllowThreads();
5158 result = ((wxRect const *)arg1)->GetPosition();
5159
5160 wxPyEndAllowThreads(__tstate);
5161 if (PyErr_Occurred()) SWIG_fail;
5162 }
5163 {
5164 wxPoint * resultptr;
5165 resultptr = new wxPoint((wxPoint &)(result));
5166 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5167 }
5168 return resultobj;
5169 fail:
5170 return NULL;
5171 }
5172
5173
5174 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5175 PyObject *resultobj;
5176 wxRect *arg1 = (wxRect *) 0 ;
5177 wxPoint *arg2 = 0 ;
5178 wxPoint temp2 ;
5179 PyObject * obj0 = 0 ;
5180 PyObject * obj1 = 0 ;
5181 char *kwnames[] = {
5182 (char *) "self",(char *) "p", NULL
5183 };
5184
5185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5187 if (SWIG_arg_fail(1)) SWIG_fail;
5188 {
5189 arg2 = &temp2;
5190 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5191 }
5192 {
5193 PyThreadState* __tstate = wxPyBeginAllowThreads();
5194 (arg1)->SetPosition((wxPoint const &)*arg2);
5195
5196 wxPyEndAllowThreads(__tstate);
5197 if (PyErr_Occurred()) SWIG_fail;
5198 }
5199 Py_INCREF(Py_None); resultobj = Py_None;
5200 return resultobj;
5201 fail:
5202 return NULL;
5203 }
5204
5205
5206 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5207 PyObject *resultobj;
5208 wxRect *arg1 = (wxRect *) 0 ;
5209 wxSize result;
5210 PyObject * obj0 = 0 ;
5211 char *kwnames[] = {
5212 (char *) "self", NULL
5213 };
5214
5215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5217 if (SWIG_arg_fail(1)) SWIG_fail;
5218 {
5219 PyThreadState* __tstate = wxPyBeginAllowThreads();
5220 result = ((wxRect const *)arg1)->GetSize();
5221
5222 wxPyEndAllowThreads(__tstate);
5223 if (PyErr_Occurred()) SWIG_fail;
5224 }
5225 {
5226 wxSize * resultptr;
5227 resultptr = new wxSize((wxSize &)(result));
5228 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5229 }
5230 return resultobj;
5231 fail:
5232 return NULL;
5233 }
5234
5235
5236 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5237 PyObject *resultobj;
5238 wxRect *arg1 = (wxRect *) 0 ;
5239 wxSize *arg2 = 0 ;
5240 wxSize temp2 ;
5241 PyObject * obj0 = 0 ;
5242 PyObject * obj1 = 0 ;
5243 char *kwnames[] = {
5244 (char *) "self",(char *) "s", NULL
5245 };
5246
5247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5249 if (SWIG_arg_fail(1)) SWIG_fail;
5250 {
5251 arg2 = &temp2;
5252 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5253 }
5254 {
5255 PyThreadState* __tstate = wxPyBeginAllowThreads();
5256 (arg1)->SetSize((wxSize const &)*arg2);
5257
5258 wxPyEndAllowThreads(__tstate);
5259 if (PyErr_Occurred()) SWIG_fail;
5260 }
5261 Py_INCREF(Py_None); resultobj = Py_None;
5262 return resultobj;
5263 fail:
5264 return NULL;
5265 }
5266
5267
5268 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5269 PyObject *resultobj;
5270 wxRect *arg1 = (wxRect *) 0 ;
5271 wxPoint result;
5272 PyObject * obj0 = 0 ;
5273 char *kwnames[] = {
5274 (char *) "self", NULL
5275 };
5276
5277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5279 if (SWIG_arg_fail(1)) SWIG_fail;
5280 {
5281 PyThreadState* __tstate = wxPyBeginAllowThreads();
5282 result = ((wxRect const *)arg1)->GetTopLeft();
5283
5284 wxPyEndAllowThreads(__tstate);
5285 if (PyErr_Occurred()) SWIG_fail;
5286 }
5287 {
5288 wxPoint * resultptr;
5289 resultptr = new wxPoint((wxPoint &)(result));
5290 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5291 }
5292 return resultobj;
5293 fail:
5294 return NULL;
5295 }
5296
5297
5298 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5299 PyObject *resultobj;
5300 wxRect *arg1 = (wxRect *) 0 ;
5301 wxPoint *arg2 = 0 ;
5302 wxPoint temp2 ;
5303 PyObject * obj0 = 0 ;
5304 PyObject * obj1 = 0 ;
5305 char *kwnames[] = {
5306 (char *) "self",(char *) "p", NULL
5307 };
5308
5309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5311 if (SWIG_arg_fail(1)) SWIG_fail;
5312 {
5313 arg2 = &temp2;
5314 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5315 }
5316 {
5317 PyThreadState* __tstate = wxPyBeginAllowThreads();
5318 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5319
5320 wxPyEndAllowThreads(__tstate);
5321 if (PyErr_Occurred()) SWIG_fail;
5322 }
5323 Py_INCREF(Py_None); resultobj = Py_None;
5324 return resultobj;
5325 fail:
5326 return NULL;
5327 }
5328
5329
5330 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5331 PyObject *resultobj;
5332 wxRect *arg1 = (wxRect *) 0 ;
5333 wxPoint result;
5334 PyObject * obj0 = 0 ;
5335 char *kwnames[] = {
5336 (char *) "self", NULL
5337 };
5338
5339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5341 if (SWIG_arg_fail(1)) SWIG_fail;
5342 {
5343 PyThreadState* __tstate = wxPyBeginAllowThreads();
5344 result = ((wxRect const *)arg1)->GetBottomRight();
5345
5346 wxPyEndAllowThreads(__tstate);
5347 if (PyErr_Occurred()) SWIG_fail;
5348 }
5349 {
5350 wxPoint * resultptr;
5351 resultptr = new wxPoint((wxPoint &)(result));
5352 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5353 }
5354 return resultobj;
5355 fail:
5356 return NULL;
5357 }
5358
5359
5360 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5361 PyObject *resultobj;
5362 wxRect *arg1 = (wxRect *) 0 ;
5363 wxPoint *arg2 = 0 ;
5364 wxPoint temp2 ;
5365 PyObject * obj0 = 0 ;
5366 PyObject * obj1 = 0 ;
5367 char *kwnames[] = {
5368 (char *) "self",(char *) "p", NULL
5369 };
5370
5371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5373 if (SWIG_arg_fail(1)) SWIG_fail;
5374 {
5375 arg2 = &temp2;
5376 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5377 }
5378 {
5379 PyThreadState* __tstate = wxPyBeginAllowThreads();
5380 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5381
5382 wxPyEndAllowThreads(__tstate);
5383 if (PyErr_Occurred()) SWIG_fail;
5384 }
5385 Py_INCREF(Py_None); resultobj = Py_None;
5386 return resultobj;
5387 fail:
5388 return NULL;
5389 }
5390
5391
5392 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5393 PyObject *resultobj;
5394 wxRect *arg1 = (wxRect *) 0 ;
5395 int result;
5396 PyObject * obj0 = 0 ;
5397 char *kwnames[] = {
5398 (char *) "self", NULL
5399 };
5400
5401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5403 if (SWIG_arg_fail(1)) SWIG_fail;
5404 {
5405 PyThreadState* __tstate = wxPyBeginAllowThreads();
5406 result = (int)((wxRect const *)arg1)->GetLeft();
5407
5408 wxPyEndAllowThreads(__tstate);
5409 if (PyErr_Occurred()) SWIG_fail;
5410 }
5411 {
5412 resultobj = SWIG_From_int((int)(result));
5413 }
5414 return resultobj;
5415 fail:
5416 return NULL;
5417 }
5418
5419
5420 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5421 PyObject *resultobj;
5422 wxRect *arg1 = (wxRect *) 0 ;
5423 int result;
5424 PyObject * obj0 = 0 ;
5425 char *kwnames[] = {
5426 (char *) "self", NULL
5427 };
5428
5429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5431 if (SWIG_arg_fail(1)) SWIG_fail;
5432 {
5433 PyThreadState* __tstate = wxPyBeginAllowThreads();
5434 result = (int)((wxRect const *)arg1)->GetTop();
5435
5436 wxPyEndAllowThreads(__tstate);
5437 if (PyErr_Occurred()) SWIG_fail;
5438 }
5439 {
5440 resultobj = SWIG_From_int((int)(result));
5441 }
5442 return resultobj;
5443 fail:
5444 return NULL;
5445 }
5446
5447
5448 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5449 PyObject *resultobj;
5450 wxRect *arg1 = (wxRect *) 0 ;
5451 int result;
5452 PyObject * obj0 = 0 ;
5453 char *kwnames[] = {
5454 (char *) "self", NULL
5455 };
5456
5457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5459 if (SWIG_arg_fail(1)) SWIG_fail;
5460 {
5461 PyThreadState* __tstate = wxPyBeginAllowThreads();
5462 result = (int)((wxRect const *)arg1)->GetBottom();
5463
5464 wxPyEndAllowThreads(__tstate);
5465 if (PyErr_Occurred()) SWIG_fail;
5466 }
5467 {
5468 resultobj = SWIG_From_int((int)(result));
5469 }
5470 return resultobj;
5471 fail:
5472 return NULL;
5473 }
5474
5475
5476 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5477 PyObject *resultobj;
5478 wxRect *arg1 = (wxRect *) 0 ;
5479 int result;
5480 PyObject * obj0 = 0 ;
5481 char *kwnames[] = {
5482 (char *) "self", NULL
5483 };
5484
5485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5487 if (SWIG_arg_fail(1)) SWIG_fail;
5488 {
5489 PyThreadState* __tstate = wxPyBeginAllowThreads();
5490 result = (int)((wxRect const *)arg1)->GetRight();
5491
5492 wxPyEndAllowThreads(__tstate);
5493 if (PyErr_Occurred()) SWIG_fail;
5494 }
5495 {
5496 resultobj = SWIG_From_int((int)(result));
5497 }
5498 return resultobj;
5499 fail:
5500 return NULL;
5501 }
5502
5503
5504 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5505 PyObject *resultobj;
5506 wxRect *arg1 = (wxRect *) 0 ;
5507 int arg2 ;
5508 PyObject * obj0 = 0 ;
5509 PyObject * obj1 = 0 ;
5510 char *kwnames[] = {
5511 (char *) "self",(char *) "left", NULL
5512 };
5513
5514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5516 if (SWIG_arg_fail(1)) SWIG_fail;
5517 {
5518 arg2 = (int)(SWIG_As_int(obj1));
5519 if (SWIG_arg_fail(2)) SWIG_fail;
5520 }
5521 {
5522 PyThreadState* __tstate = wxPyBeginAllowThreads();
5523 (arg1)->SetLeft(arg2);
5524
5525 wxPyEndAllowThreads(__tstate);
5526 if (PyErr_Occurred()) SWIG_fail;
5527 }
5528 Py_INCREF(Py_None); resultobj = Py_None;
5529 return resultobj;
5530 fail:
5531 return NULL;
5532 }
5533
5534
5535 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5536 PyObject *resultobj;
5537 wxRect *arg1 = (wxRect *) 0 ;
5538 int arg2 ;
5539 PyObject * obj0 = 0 ;
5540 PyObject * obj1 = 0 ;
5541 char *kwnames[] = {
5542 (char *) "self",(char *) "right", NULL
5543 };
5544
5545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5547 if (SWIG_arg_fail(1)) SWIG_fail;
5548 {
5549 arg2 = (int)(SWIG_As_int(obj1));
5550 if (SWIG_arg_fail(2)) SWIG_fail;
5551 }
5552 {
5553 PyThreadState* __tstate = wxPyBeginAllowThreads();
5554 (arg1)->SetRight(arg2);
5555
5556 wxPyEndAllowThreads(__tstate);
5557 if (PyErr_Occurred()) SWIG_fail;
5558 }
5559 Py_INCREF(Py_None); resultobj = Py_None;
5560 return resultobj;
5561 fail:
5562 return NULL;
5563 }
5564
5565
5566 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5567 PyObject *resultobj;
5568 wxRect *arg1 = (wxRect *) 0 ;
5569 int arg2 ;
5570 PyObject * obj0 = 0 ;
5571 PyObject * obj1 = 0 ;
5572 char *kwnames[] = {
5573 (char *) "self",(char *) "top", NULL
5574 };
5575
5576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5578 if (SWIG_arg_fail(1)) SWIG_fail;
5579 {
5580 arg2 = (int)(SWIG_As_int(obj1));
5581 if (SWIG_arg_fail(2)) SWIG_fail;
5582 }
5583 {
5584 PyThreadState* __tstate = wxPyBeginAllowThreads();
5585 (arg1)->SetTop(arg2);
5586
5587 wxPyEndAllowThreads(__tstate);
5588 if (PyErr_Occurred()) SWIG_fail;
5589 }
5590 Py_INCREF(Py_None); resultobj = Py_None;
5591 return resultobj;
5592 fail:
5593 return NULL;
5594 }
5595
5596
5597 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5598 PyObject *resultobj;
5599 wxRect *arg1 = (wxRect *) 0 ;
5600 int arg2 ;
5601 PyObject * obj0 = 0 ;
5602 PyObject * obj1 = 0 ;
5603 char *kwnames[] = {
5604 (char *) "self",(char *) "bottom", NULL
5605 };
5606
5607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5609 if (SWIG_arg_fail(1)) SWIG_fail;
5610 {
5611 arg2 = (int)(SWIG_As_int(obj1));
5612 if (SWIG_arg_fail(2)) SWIG_fail;
5613 }
5614 {
5615 PyThreadState* __tstate = wxPyBeginAllowThreads();
5616 (arg1)->SetBottom(arg2);
5617
5618 wxPyEndAllowThreads(__tstate);
5619 if (PyErr_Occurred()) SWIG_fail;
5620 }
5621 Py_INCREF(Py_None); resultobj = Py_None;
5622 return resultobj;
5623 fail:
5624 return NULL;
5625 }
5626
5627
5628 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5629 PyObject *resultobj;
5630 wxRect *arg1 = (wxRect *) 0 ;
5631 int arg2 ;
5632 int arg3 ;
5633 wxRect *result;
5634 PyObject * obj0 = 0 ;
5635 PyObject * obj1 = 0 ;
5636 PyObject * obj2 = 0 ;
5637 char *kwnames[] = {
5638 (char *) "self",(char *) "dx",(char *) "dy", NULL
5639 };
5640
5641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5643 if (SWIG_arg_fail(1)) SWIG_fail;
5644 {
5645 arg2 = (int)(SWIG_As_int(obj1));
5646 if (SWIG_arg_fail(2)) SWIG_fail;
5647 }
5648 {
5649 arg3 = (int)(SWIG_As_int(obj2));
5650 if (SWIG_arg_fail(3)) SWIG_fail;
5651 }
5652 {
5653 PyThreadState* __tstate = wxPyBeginAllowThreads();
5654 {
5655 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5656 result = (wxRect *) &_result_ref;
5657 }
5658
5659 wxPyEndAllowThreads(__tstate);
5660 if (PyErr_Occurred()) SWIG_fail;
5661 }
5662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5663 return resultobj;
5664 fail:
5665 return NULL;
5666 }
5667
5668
5669 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5670 PyObject *resultobj;
5671 wxRect *arg1 = (wxRect *) 0 ;
5672 int arg2 ;
5673 int arg3 ;
5674 wxRect *result;
5675 PyObject * obj0 = 0 ;
5676 PyObject * obj1 = 0 ;
5677 PyObject * obj2 = 0 ;
5678 char *kwnames[] = {
5679 (char *) "self",(char *) "dx",(char *) "dy", NULL
5680 };
5681
5682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5684 if (SWIG_arg_fail(1)) SWIG_fail;
5685 {
5686 arg2 = (int)(SWIG_As_int(obj1));
5687 if (SWIG_arg_fail(2)) SWIG_fail;
5688 }
5689 {
5690 arg3 = (int)(SWIG_As_int(obj2));
5691 if (SWIG_arg_fail(3)) SWIG_fail;
5692 }
5693 {
5694 PyThreadState* __tstate = wxPyBeginAllowThreads();
5695 {
5696 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5697 result = (wxRect *) &_result_ref;
5698 }
5699
5700 wxPyEndAllowThreads(__tstate);
5701 if (PyErr_Occurred()) SWIG_fail;
5702 }
5703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5704 return resultobj;
5705 fail:
5706 return NULL;
5707 }
5708
5709
5710 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5711 PyObject *resultobj;
5712 wxRect *arg1 = (wxRect *) 0 ;
5713 int arg2 ;
5714 int arg3 ;
5715 PyObject * obj0 = 0 ;
5716 PyObject * obj1 = 0 ;
5717 PyObject * obj2 = 0 ;
5718 char *kwnames[] = {
5719 (char *) "self",(char *) "dx",(char *) "dy", NULL
5720 };
5721
5722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5724 if (SWIG_arg_fail(1)) SWIG_fail;
5725 {
5726 arg2 = (int)(SWIG_As_int(obj1));
5727 if (SWIG_arg_fail(2)) SWIG_fail;
5728 }
5729 {
5730 arg3 = (int)(SWIG_As_int(obj2));
5731 if (SWIG_arg_fail(3)) SWIG_fail;
5732 }
5733 {
5734 PyThreadState* __tstate = wxPyBeginAllowThreads();
5735 (arg1)->Offset(arg2,arg3);
5736
5737 wxPyEndAllowThreads(__tstate);
5738 if (PyErr_Occurred()) SWIG_fail;
5739 }
5740 Py_INCREF(Py_None); resultobj = Py_None;
5741 return resultobj;
5742 fail:
5743 return NULL;
5744 }
5745
5746
5747 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5748 PyObject *resultobj;
5749 wxRect *arg1 = (wxRect *) 0 ;
5750 wxPoint *arg2 = 0 ;
5751 wxPoint temp2 ;
5752 PyObject * obj0 = 0 ;
5753 PyObject * obj1 = 0 ;
5754 char *kwnames[] = {
5755 (char *) "self",(char *) "pt", NULL
5756 };
5757
5758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5760 if (SWIG_arg_fail(1)) SWIG_fail;
5761 {
5762 arg2 = &temp2;
5763 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5764 }
5765 {
5766 PyThreadState* __tstate = wxPyBeginAllowThreads();
5767 (arg1)->Offset((wxPoint const &)*arg2);
5768
5769 wxPyEndAllowThreads(__tstate);
5770 if (PyErr_Occurred()) SWIG_fail;
5771 }
5772 Py_INCREF(Py_None); resultobj = Py_None;
5773 return resultobj;
5774 fail:
5775 return NULL;
5776 }
5777
5778
5779 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5780 PyObject *resultobj;
5781 wxRect *arg1 = (wxRect *) 0 ;
5782 wxRect *arg2 = 0 ;
5783 wxRect result;
5784 wxRect temp2 ;
5785 PyObject * obj0 = 0 ;
5786 PyObject * obj1 = 0 ;
5787 char *kwnames[] = {
5788 (char *) "self",(char *) "rect", NULL
5789 };
5790
5791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5793 if (SWIG_arg_fail(1)) SWIG_fail;
5794 {
5795 arg2 = &temp2;
5796 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5797 }
5798 {
5799 PyThreadState* __tstate = wxPyBeginAllowThreads();
5800 result = (arg1)->Intersect((wxRect const &)*arg2);
5801
5802 wxPyEndAllowThreads(__tstate);
5803 if (PyErr_Occurred()) SWIG_fail;
5804 }
5805 {
5806 wxRect * resultptr;
5807 resultptr = new wxRect((wxRect &)(result));
5808 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5809 }
5810 return resultobj;
5811 fail:
5812 return NULL;
5813 }
5814
5815
5816 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5817 PyObject *resultobj;
5818 wxRect *arg1 = (wxRect *) 0 ;
5819 wxRect *arg2 = 0 ;
5820 wxRect result;
5821 wxRect temp2 ;
5822 PyObject * obj0 = 0 ;
5823 PyObject * obj1 = 0 ;
5824 char *kwnames[] = {
5825 (char *) "self",(char *) "rect", NULL
5826 };
5827
5828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5830 if (SWIG_arg_fail(1)) SWIG_fail;
5831 {
5832 arg2 = &temp2;
5833 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5834 }
5835 {
5836 PyThreadState* __tstate = wxPyBeginAllowThreads();
5837 result = (arg1)->Union((wxRect const &)*arg2);
5838
5839 wxPyEndAllowThreads(__tstate);
5840 if (PyErr_Occurred()) SWIG_fail;
5841 }
5842 {
5843 wxRect * resultptr;
5844 resultptr = new wxRect((wxRect &)(result));
5845 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5846 }
5847 return resultobj;
5848 fail:
5849 return NULL;
5850 }
5851
5852
5853 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5854 PyObject *resultobj;
5855 wxRect *arg1 = (wxRect *) 0 ;
5856 wxRect *arg2 = 0 ;
5857 wxRect result;
5858 wxRect temp2 ;
5859 PyObject * obj0 = 0 ;
5860 PyObject * obj1 = 0 ;
5861 char *kwnames[] = {
5862 (char *) "self",(char *) "rect", NULL
5863 };
5864
5865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5867 if (SWIG_arg_fail(1)) SWIG_fail;
5868 {
5869 arg2 = &temp2;
5870 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5871 }
5872 {
5873 PyThreadState* __tstate = wxPyBeginAllowThreads();
5874 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5875
5876 wxPyEndAllowThreads(__tstate);
5877 if (PyErr_Occurred()) SWIG_fail;
5878 }
5879 {
5880 wxRect * resultptr;
5881 resultptr = new wxRect((wxRect &)(result));
5882 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5883 }
5884 return resultobj;
5885 fail:
5886 return NULL;
5887 }
5888
5889
5890 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5891 PyObject *resultobj;
5892 wxRect *arg1 = (wxRect *) 0 ;
5893 wxRect *arg2 = 0 ;
5894 wxRect *result;
5895 wxRect temp2 ;
5896 PyObject * obj0 = 0 ;
5897 PyObject * obj1 = 0 ;
5898 char *kwnames[] = {
5899 (char *) "self",(char *) "rect", NULL
5900 };
5901
5902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5904 if (SWIG_arg_fail(1)) SWIG_fail;
5905 {
5906 arg2 = &temp2;
5907 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5908 }
5909 {
5910 PyThreadState* __tstate = wxPyBeginAllowThreads();
5911 {
5912 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5913 result = (wxRect *) &_result_ref;
5914 }
5915
5916 wxPyEndAllowThreads(__tstate);
5917 if (PyErr_Occurred()) SWIG_fail;
5918 }
5919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5920 return resultobj;
5921 fail:
5922 return NULL;
5923 }
5924
5925
5926 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5927 PyObject *resultobj;
5928 wxRect *arg1 = (wxRect *) 0 ;
5929 wxRect *arg2 = 0 ;
5930 bool result;
5931 wxRect temp2 ;
5932 PyObject * obj0 = 0 ;
5933 PyObject * obj1 = 0 ;
5934 char *kwnames[] = {
5935 (char *) "self",(char *) "rect", NULL
5936 };
5937
5938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5940 if (SWIG_arg_fail(1)) SWIG_fail;
5941 {
5942 arg2 = &temp2;
5943 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5944 }
5945 {
5946 PyThreadState* __tstate = wxPyBeginAllowThreads();
5947 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5948
5949 wxPyEndAllowThreads(__tstate);
5950 if (PyErr_Occurred()) SWIG_fail;
5951 }
5952 {
5953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5954 }
5955 return resultobj;
5956 fail:
5957 return NULL;
5958 }
5959
5960
5961 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5962 PyObject *resultobj;
5963 wxRect *arg1 = (wxRect *) 0 ;
5964 wxRect *arg2 = 0 ;
5965 bool result;
5966 wxRect temp2 ;
5967 PyObject * obj0 = 0 ;
5968 PyObject * obj1 = 0 ;
5969 char *kwnames[] = {
5970 (char *) "self",(char *) "rect", NULL
5971 };
5972
5973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
5974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5975 if (SWIG_arg_fail(1)) SWIG_fail;
5976 {
5977 arg2 = &temp2;
5978 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5979 }
5980 {
5981 PyThreadState* __tstate = wxPyBeginAllowThreads();
5982 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
5983
5984 wxPyEndAllowThreads(__tstate);
5985 if (PyErr_Occurred()) SWIG_fail;
5986 }
5987 {
5988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5989 }
5990 return resultobj;
5991 fail:
5992 return NULL;
5993 }
5994
5995
5996 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
5997 PyObject *resultobj;
5998 wxRect *arg1 = (wxRect *) 0 ;
5999 int arg2 ;
6000 int arg3 ;
6001 bool result;
6002 PyObject * obj0 = 0 ;
6003 PyObject * obj1 = 0 ;
6004 PyObject * obj2 = 0 ;
6005 char *kwnames[] = {
6006 (char *) "self",(char *) "x",(char *) "y", NULL
6007 };
6008
6009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6011 if (SWIG_arg_fail(1)) SWIG_fail;
6012 {
6013 arg2 = (int)(SWIG_As_int(obj1));
6014 if (SWIG_arg_fail(2)) SWIG_fail;
6015 }
6016 {
6017 arg3 = (int)(SWIG_As_int(obj2));
6018 if (SWIG_arg_fail(3)) SWIG_fail;
6019 }
6020 {
6021 PyThreadState* __tstate = wxPyBeginAllowThreads();
6022 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6023
6024 wxPyEndAllowThreads(__tstate);
6025 if (PyErr_Occurred()) SWIG_fail;
6026 }
6027 {
6028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6029 }
6030 return resultobj;
6031 fail:
6032 return NULL;
6033 }
6034
6035
6036 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6037 PyObject *resultobj;
6038 wxRect *arg1 = (wxRect *) 0 ;
6039 wxPoint *arg2 = 0 ;
6040 bool result;
6041 wxPoint temp2 ;
6042 PyObject * obj0 = 0 ;
6043 PyObject * obj1 = 0 ;
6044 char *kwnames[] = {
6045 (char *) "self",(char *) "pt", NULL
6046 };
6047
6048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6050 if (SWIG_arg_fail(1)) SWIG_fail;
6051 {
6052 arg2 = &temp2;
6053 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6054 }
6055 {
6056 PyThreadState* __tstate = wxPyBeginAllowThreads();
6057 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6058
6059 wxPyEndAllowThreads(__tstate);
6060 if (PyErr_Occurred()) SWIG_fail;
6061 }
6062 {
6063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6064 }
6065 return resultobj;
6066 fail:
6067 return NULL;
6068 }
6069
6070
6071 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6072 PyObject *resultobj;
6073 wxRect *arg1 = (wxRect *) 0 ;
6074 wxRect *arg2 = 0 ;
6075 bool result;
6076 wxRect temp2 ;
6077 PyObject * obj0 = 0 ;
6078 PyObject * obj1 = 0 ;
6079 char *kwnames[] = {
6080 (char *) "self",(char *) "rect", NULL
6081 };
6082
6083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6085 if (SWIG_arg_fail(1)) SWIG_fail;
6086 {
6087 arg2 = &temp2;
6088 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6089 }
6090 {
6091 PyThreadState* __tstate = wxPyBeginAllowThreads();
6092 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6093
6094 wxPyEndAllowThreads(__tstate);
6095 if (PyErr_Occurred()) SWIG_fail;
6096 }
6097 {
6098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6099 }
6100 return resultobj;
6101 fail:
6102 return NULL;
6103 }
6104
6105
6106 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6107 PyObject *resultobj;
6108 wxRect *arg1 = (wxRect *) 0 ;
6109 int arg2 ;
6110 PyObject * obj0 = 0 ;
6111 PyObject * obj1 = 0 ;
6112 char *kwnames[] = {
6113 (char *) "self",(char *) "x", NULL
6114 };
6115
6116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6118 if (SWIG_arg_fail(1)) SWIG_fail;
6119 {
6120 arg2 = (int)(SWIG_As_int(obj1));
6121 if (SWIG_arg_fail(2)) SWIG_fail;
6122 }
6123 if (arg1) (arg1)->x = arg2;
6124
6125 Py_INCREF(Py_None); resultobj = Py_None;
6126 return resultobj;
6127 fail:
6128 return NULL;
6129 }
6130
6131
6132 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6133 PyObject *resultobj;
6134 wxRect *arg1 = (wxRect *) 0 ;
6135 int result;
6136 PyObject * obj0 = 0 ;
6137 char *kwnames[] = {
6138 (char *) "self", NULL
6139 };
6140
6141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6143 if (SWIG_arg_fail(1)) SWIG_fail;
6144 result = (int) ((arg1)->x);
6145
6146 {
6147 resultobj = SWIG_From_int((int)(result));
6148 }
6149 return resultobj;
6150 fail:
6151 return NULL;
6152 }
6153
6154
6155 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6156 PyObject *resultobj;
6157 wxRect *arg1 = (wxRect *) 0 ;
6158 int arg2 ;
6159 PyObject * obj0 = 0 ;
6160 PyObject * obj1 = 0 ;
6161 char *kwnames[] = {
6162 (char *) "self",(char *) "y", NULL
6163 };
6164
6165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6167 if (SWIG_arg_fail(1)) SWIG_fail;
6168 {
6169 arg2 = (int)(SWIG_As_int(obj1));
6170 if (SWIG_arg_fail(2)) SWIG_fail;
6171 }
6172 if (arg1) (arg1)->y = arg2;
6173
6174 Py_INCREF(Py_None); resultobj = Py_None;
6175 return resultobj;
6176 fail:
6177 return NULL;
6178 }
6179
6180
6181 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6182 PyObject *resultobj;
6183 wxRect *arg1 = (wxRect *) 0 ;
6184 int result;
6185 PyObject * obj0 = 0 ;
6186 char *kwnames[] = {
6187 (char *) "self", NULL
6188 };
6189
6190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6192 if (SWIG_arg_fail(1)) SWIG_fail;
6193 result = (int) ((arg1)->y);
6194
6195 {
6196 resultobj = SWIG_From_int((int)(result));
6197 }
6198 return resultobj;
6199 fail:
6200 return NULL;
6201 }
6202
6203
6204 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6205 PyObject *resultobj;
6206 wxRect *arg1 = (wxRect *) 0 ;
6207 int arg2 ;
6208 PyObject * obj0 = 0 ;
6209 PyObject * obj1 = 0 ;
6210 char *kwnames[] = {
6211 (char *) "self",(char *) "width", NULL
6212 };
6213
6214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6216 if (SWIG_arg_fail(1)) SWIG_fail;
6217 {
6218 arg2 = (int)(SWIG_As_int(obj1));
6219 if (SWIG_arg_fail(2)) SWIG_fail;
6220 }
6221 if (arg1) (arg1)->width = arg2;
6222
6223 Py_INCREF(Py_None); resultobj = Py_None;
6224 return resultobj;
6225 fail:
6226 return NULL;
6227 }
6228
6229
6230 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6231 PyObject *resultobj;
6232 wxRect *arg1 = (wxRect *) 0 ;
6233 int result;
6234 PyObject * obj0 = 0 ;
6235 char *kwnames[] = {
6236 (char *) "self", NULL
6237 };
6238
6239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6241 if (SWIG_arg_fail(1)) SWIG_fail;
6242 result = (int) ((arg1)->width);
6243
6244 {
6245 resultobj = SWIG_From_int((int)(result));
6246 }
6247 return resultobj;
6248 fail:
6249 return NULL;
6250 }
6251
6252
6253 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6254 PyObject *resultobj;
6255 wxRect *arg1 = (wxRect *) 0 ;
6256 int arg2 ;
6257 PyObject * obj0 = 0 ;
6258 PyObject * obj1 = 0 ;
6259 char *kwnames[] = {
6260 (char *) "self",(char *) "height", NULL
6261 };
6262
6263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6265 if (SWIG_arg_fail(1)) SWIG_fail;
6266 {
6267 arg2 = (int)(SWIG_As_int(obj1));
6268 if (SWIG_arg_fail(2)) SWIG_fail;
6269 }
6270 if (arg1) (arg1)->height = arg2;
6271
6272 Py_INCREF(Py_None); resultobj = Py_None;
6273 return resultobj;
6274 fail:
6275 return NULL;
6276 }
6277
6278
6279 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6280 PyObject *resultobj;
6281 wxRect *arg1 = (wxRect *) 0 ;
6282 int result;
6283 PyObject * obj0 = 0 ;
6284 char *kwnames[] = {
6285 (char *) "self", NULL
6286 };
6287
6288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6290 if (SWIG_arg_fail(1)) SWIG_fail;
6291 result = (int) ((arg1)->height);
6292
6293 {
6294 resultobj = SWIG_From_int((int)(result));
6295 }
6296 return resultobj;
6297 fail:
6298 return NULL;
6299 }
6300
6301
6302 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6303 PyObject *resultobj;
6304 wxRect *arg1 = (wxRect *) 0 ;
6305 int arg2 = (int) 0 ;
6306 int arg3 = (int) 0 ;
6307 int arg4 = (int) 0 ;
6308 int arg5 = (int) 0 ;
6309 PyObject * obj0 = 0 ;
6310 PyObject * obj1 = 0 ;
6311 PyObject * obj2 = 0 ;
6312 PyObject * obj3 = 0 ;
6313 PyObject * obj4 = 0 ;
6314 char *kwnames[] = {
6315 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6316 };
6317
6318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6320 if (SWIG_arg_fail(1)) SWIG_fail;
6321 if (obj1) {
6322 {
6323 arg2 = (int)(SWIG_As_int(obj1));
6324 if (SWIG_arg_fail(2)) SWIG_fail;
6325 }
6326 }
6327 if (obj2) {
6328 {
6329 arg3 = (int)(SWIG_As_int(obj2));
6330 if (SWIG_arg_fail(3)) SWIG_fail;
6331 }
6332 }
6333 if (obj3) {
6334 {
6335 arg4 = (int)(SWIG_As_int(obj3));
6336 if (SWIG_arg_fail(4)) SWIG_fail;
6337 }
6338 }
6339 if (obj4) {
6340 {
6341 arg5 = (int)(SWIG_As_int(obj4));
6342 if (SWIG_arg_fail(5)) SWIG_fail;
6343 }
6344 }
6345 {
6346 PyThreadState* __tstate = wxPyBeginAllowThreads();
6347 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6348
6349 wxPyEndAllowThreads(__tstate);
6350 if (PyErr_Occurred()) SWIG_fail;
6351 }
6352 Py_INCREF(Py_None); resultobj = Py_None;
6353 return resultobj;
6354 fail:
6355 return NULL;
6356 }
6357
6358
6359 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6360 PyObject *resultobj;
6361 wxRect *arg1 = (wxRect *) 0 ;
6362 PyObject *result;
6363 PyObject * obj0 = 0 ;
6364 char *kwnames[] = {
6365 (char *) "self", NULL
6366 };
6367
6368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6370 if (SWIG_arg_fail(1)) SWIG_fail;
6371 {
6372 PyThreadState* __tstate = wxPyBeginAllowThreads();
6373 result = (PyObject *)wxRect_Get(arg1);
6374
6375 wxPyEndAllowThreads(__tstate);
6376 if (PyErr_Occurred()) SWIG_fail;
6377 }
6378 resultobj = result;
6379 return resultobj;
6380 fail:
6381 return NULL;
6382 }
6383
6384
6385 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6386 PyObject *obj;
6387 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6388 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6389 Py_INCREF(obj);
6390 return Py_BuildValue((char *)"");
6391 }
6392 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6393 PyObject *resultobj;
6394 wxRect *arg1 = (wxRect *) 0 ;
6395 wxRect *arg2 = (wxRect *) 0 ;
6396 PyObject *result;
6397 PyObject * obj0 = 0 ;
6398 PyObject * obj1 = 0 ;
6399 char *kwnames[] = {
6400 (char *) "r1",(char *) "r2", NULL
6401 };
6402
6403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6405 if (SWIG_arg_fail(1)) SWIG_fail;
6406 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6407 if (SWIG_arg_fail(2)) SWIG_fail;
6408 {
6409 if (!wxPyCheckForApp()) SWIG_fail;
6410 PyThreadState* __tstate = wxPyBeginAllowThreads();
6411 result = (PyObject *)wxIntersectRect(arg1,arg2);
6412
6413 wxPyEndAllowThreads(__tstate);
6414 if (PyErr_Occurred()) SWIG_fail;
6415 }
6416 resultobj = result;
6417 return resultobj;
6418 fail:
6419 return NULL;
6420 }
6421
6422
6423 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6424 PyObject *resultobj;
6425 double arg1 = (double) 0.0 ;
6426 double arg2 = (double) 0.0 ;
6427 wxPoint2D *result;
6428 PyObject * obj0 = 0 ;
6429 PyObject * obj1 = 0 ;
6430 char *kwnames[] = {
6431 (char *) "x",(char *) "y", NULL
6432 };
6433
6434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6435 if (obj0) {
6436 {
6437 arg1 = (double)(SWIG_As_double(obj0));
6438 if (SWIG_arg_fail(1)) SWIG_fail;
6439 }
6440 }
6441 if (obj1) {
6442 {
6443 arg2 = (double)(SWIG_As_double(obj1));
6444 if (SWIG_arg_fail(2)) SWIG_fail;
6445 }
6446 }
6447 {
6448 PyThreadState* __tstate = wxPyBeginAllowThreads();
6449 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6450
6451 wxPyEndAllowThreads(__tstate);
6452 if (PyErr_Occurred()) SWIG_fail;
6453 }
6454 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6455 return resultobj;
6456 fail:
6457 return NULL;
6458 }
6459
6460
6461 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6462 PyObject *resultobj;
6463 wxPoint2D *arg1 = 0 ;
6464 wxPoint2D *result;
6465 wxPoint2D temp1 ;
6466 PyObject * obj0 = 0 ;
6467 char *kwnames[] = {
6468 (char *) "pt", NULL
6469 };
6470
6471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6472 {
6473 arg1 = &temp1;
6474 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6475 }
6476 {
6477 PyThreadState* __tstate = wxPyBeginAllowThreads();
6478 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6479
6480 wxPyEndAllowThreads(__tstate);
6481 if (PyErr_Occurred()) SWIG_fail;
6482 }
6483 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6484 return resultobj;
6485 fail:
6486 return NULL;
6487 }
6488
6489
6490 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6491 PyObject *resultobj;
6492 wxPoint *arg1 = 0 ;
6493 wxPoint2D *result;
6494 wxPoint temp1 ;
6495 PyObject * obj0 = 0 ;
6496 char *kwnames[] = {
6497 (char *) "pt", NULL
6498 };
6499
6500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6501 {
6502 arg1 = &temp1;
6503 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6504 }
6505 {
6506 PyThreadState* __tstate = wxPyBeginAllowThreads();
6507 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6508
6509 wxPyEndAllowThreads(__tstate);
6510 if (PyErr_Occurred()) SWIG_fail;
6511 }
6512 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6513 return resultobj;
6514 fail:
6515 return NULL;
6516 }
6517
6518
6519 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6520 PyObject *resultobj;
6521 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6522 int *arg2 = (int *) 0 ;
6523 int *arg3 = (int *) 0 ;
6524 int temp2 ;
6525 int res2 = 0 ;
6526 int temp3 ;
6527 int res3 = 0 ;
6528 PyObject * obj0 = 0 ;
6529 char *kwnames[] = {
6530 (char *) "self", NULL
6531 };
6532
6533 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6534 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6537 if (SWIG_arg_fail(1)) SWIG_fail;
6538 {
6539 PyThreadState* __tstate = wxPyBeginAllowThreads();
6540 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6541
6542 wxPyEndAllowThreads(__tstate);
6543 if (PyErr_Occurred()) SWIG_fail;
6544 }
6545 Py_INCREF(Py_None); resultobj = Py_None;
6546 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6547 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6548 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6549 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6550 return resultobj;
6551 fail:
6552 return NULL;
6553 }
6554
6555
6556 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6557 PyObject *resultobj;
6558 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6559 int *arg2 = (int *) 0 ;
6560 int *arg3 = (int *) 0 ;
6561 int temp2 ;
6562 int res2 = 0 ;
6563 int temp3 ;
6564 int res3 = 0 ;
6565 PyObject * obj0 = 0 ;
6566 char *kwnames[] = {
6567 (char *) "self", NULL
6568 };
6569
6570 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6571 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6574 if (SWIG_arg_fail(1)) SWIG_fail;
6575 {
6576 PyThreadState* __tstate = wxPyBeginAllowThreads();
6577 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6578
6579 wxPyEndAllowThreads(__tstate);
6580 if (PyErr_Occurred()) SWIG_fail;
6581 }
6582 Py_INCREF(Py_None); resultobj = Py_None;
6583 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6584 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6585 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6586 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6587 return resultobj;
6588 fail:
6589 return NULL;
6590 }
6591
6592
6593 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6594 PyObject *resultobj;
6595 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6596 double result;
6597 PyObject * obj0 = 0 ;
6598 char *kwnames[] = {
6599 (char *) "self", NULL
6600 };
6601
6602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6604 if (SWIG_arg_fail(1)) SWIG_fail;
6605 {
6606 PyThreadState* __tstate = wxPyBeginAllowThreads();
6607 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6608
6609 wxPyEndAllowThreads(__tstate);
6610 if (PyErr_Occurred()) SWIG_fail;
6611 }
6612 {
6613 resultobj = SWIG_From_double((double)(result));
6614 }
6615 return resultobj;
6616 fail:
6617 return NULL;
6618 }
6619
6620
6621 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6622 PyObject *resultobj;
6623 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6624 double result;
6625 PyObject * obj0 = 0 ;
6626 char *kwnames[] = {
6627 (char *) "self", NULL
6628 };
6629
6630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6632 if (SWIG_arg_fail(1)) SWIG_fail;
6633 {
6634 PyThreadState* __tstate = wxPyBeginAllowThreads();
6635 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6636
6637 wxPyEndAllowThreads(__tstate);
6638 if (PyErr_Occurred()) SWIG_fail;
6639 }
6640 {
6641 resultobj = SWIG_From_double((double)(result));
6642 }
6643 return resultobj;
6644 fail:
6645 return NULL;
6646 }
6647
6648
6649 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6650 PyObject *resultobj;
6651 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6652 double arg2 ;
6653 PyObject * obj0 = 0 ;
6654 PyObject * obj1 = 0 ;
6655 char *kwnames[] = {
6656 (char *) "self",(char *) "length", NULL
6657 };
6658
6659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6661 if (SWIG_arg_fail(1)) SWIG_fail;
6662 {
6663 arg2 = (double)(SWIG_As_double(obj1));
6664 if (SWIG_arg_fail(2)) SWIG_fail;
6665 }
6666 {
6667 PyThreadState* __tstate = wxPyBeginAllowThreads();
6668 (arg1)->SetVectorLength(arg2);
6669
6670 wxPyEndAllowThreads(__tstate);
6671 if (PyErr_Occurred()) SWIG_fail;
6672 }
6673 Py_INCREF(Py_None); resultobj = Py_None;
6674 return resultobj;
6675 fail:
6676 return NULL;
6677 }
6678
6679
6680 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6681 PyObject *resultobj;
6682 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6683 double arg2 ;
6684 PyObject * obj0 = 0 ;
6685 PyObject * obj1 = 0 ;
6686 char *kwnames[] = {
6687 (char *) "self",(char *) "degrees", NULL
6688 };
6689
6690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6692 if (SWIG_arg_fail(1)) SWIG_fail;
6693 {
6694 arg2 = (double)(SWIG_As_double(obj1));
6695 if (SWIG_arg_fail(2)) SWIG_fail;
6696 }
6697 {
6698 PyThreadState* __tstate = wxPyBeginAllowThreads();
6699 (arg1)->SetVectorAngle(arg2);
6700
6701 wxPyEndAllowThreads(__tstate);
6702 if (PyErr_Occurred()) SWIG_fail;
6703 }
6704 Py_INCREF(Py_None); resultobj = Py_None;
6705 return resultobj;
6706 fail:
6707 return NULL;
6708 }
6709
6710
6711 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6712 PyObject *resultobj;
6713 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6714 wxPoint2D *arg2 = 0 ;
6715 double result;
6716 wxPoint2D temp2 ;
6717 PyObject * obj0 = 0 ;
6718 PyObject * obj1 = 0 ;
6719 char *kwnames[] = {
6720 (char *) "self",(char *) "pt", NULL
6721 };
6722
6723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6725 if (SWIG_arg_fail(1)) SWIG_fail;
6726 {
6727 arg2 = &temp2;
6728 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6729 }
6730 {
6731 PyThreadState* __tstate = wxPyBeginAllowThreads();
6732 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6733
6734 wxPyEndAllowThreads(__tstate);
6735 if (PyErr_Occurred()) SWIG_fail;
6736 }
6737 {
6738 resultobj = SWIG_From_double((double)(result));
6739 }
6740 return resultobj;
6741 fail:
6742 return NULL;
6743 }
6744
6745
6746 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6747 PyObject *resultobj;
6748 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6749 wxPoint2D *arg2 = 0 ;
6750 double result;
6751 wxPoint2D temp2 ;
6752 PyObject * obj0 = 0 ;
6753 PyObject * obj1 = 0 ;
6754 char *kwnames[] = {
6755 (char *) "self",(char *) "pt", NULL
6756 };
6757
6758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6760 if (SWIG_arg_fail(1)) SWIG_fail;
6761 {
6762 arg2 = &temp2;
6763 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6764 }
6765 {
6766 PyThreadState* __tstate = wxPyBeginAllowThreads();
6767 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6768
6769 wxPyEndAllowThreads(__tstate);
6770 if (PyErr_Occurred()) SWIG_fail;
6771 }
6772 {
6773 resultobj = SWIG_From_double((double)(result));
6774 }
6775 return resultobj;
6776 fail:
6777 return NULL;
6778 }
6779
6780
6781 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6782 PyObject *resultobj;
6783 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6784 wxPoint2D *arg2 = 0 ;
6785 double result;
6786 wxPoint2D temp2 ;
6787 PyObject * obj0 = 0 ;
6788 PyObject * obj1 = 0 ;
6789 char *kwnames[] = {
6790 (char *) "self",(char *) "vec", NULL
6791 };
6792
6793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6795 if (SWIG_arg_fail(1)) SWIG_fail;
6796 {
6797 arg2 = &temp2;
6798 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6799 }
6800 {
6801 PyThreadState* __tstate = wxPyBeginAllowThreads();
6802 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6803
6804 wxPyEndAllowThreads(__tstate);
6805 if (PyErr_Occurred()) SWIG_fail;
6806 }
6807 {
6808 resultobj = SWIG_From_double((double)(result));
6809 }
6810 return resultobj;
6811 fail:
6812 return NULL;
6813 }
6814
6815
6816 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6817 PyObject *resultobj;
6818 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6819 wxPoint2D *arg2 = 0 ;
6820 double result;
6821 wxPoint2D temp2 ;
6822 PyObject * obj0 = 0 ;
6823 PyObject * obj1 = 0 ;
6824 char *kwnames[] = {
6825 (char *) "self",(char *) "vec", NULL
6826 };
6827
6828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6830 if (SWIG_arg_fail(1)) SWIG_fail;
6831 {
6832 arg2 = &temp2;
6833 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6834 }
6835 {
6836 PyThreadState* __tstate = wxPyBeginAllowThreads();
6837 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6838
6839 wxPyEndAllowThreads(__tstate);
6840 if (PyErr_Occurred()) SWIG_fail;
6841 }
6842 {
6843 resultobj = SWIG_From_double((double)(result));
6844 }
6845 return resultobj;
6846 fail:
6847 return NULL;
6848 }
6849
6850
6851 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6852 PyObject *resultobj;
6853 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6854 wxPoint2D result;
6855 PyObject * obj0 = 0 ;
6856 char *kwnames[] = {
6857 (char *) "self", NULL
6858 };
6859
6860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6862 if (SWIG_arg_fail(1)) SWIG_fail;
6863 {
6864 PyThreadState* __tstate = wxPyBeginAllowThreads();
6865 result = (arg1)->operator -();
6866
6867 wxPyEndAllowThreads(__tstate);
6868 if (PyErr_Occurred()) SWIG_fail;
6869 }
6870 {
6871 wxPoint2D * resultptr;
6872 resultptr = new wxPoint2D((wxPoint2D &)(result));
6873 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6874 }
6875 return resultobj;
6876 fail:
6877 return NULL;
6878 }
6879
6880
6881 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6882 PyObject *resultobj;
6883 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6884 wxPoint2D *arg2 = 0 ;
6885 wxPoint2D *result;
6886 wxPoint2D temp2 ;
6887 PyObject * obj0 = 0 ;
6888 PyObject * obj1 = 0 ;
6889 char *kwnames[] = {
6890 (char *) "self",(char *) "pt", NULL
6891 };
6892
6893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6895 if (SWIG_arg_fail(1)) SWIG_fail;
6896 {
6897 arg2 = &temp2;
6898 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6899 }
6900 {
6901 PyThreadState* __tstate = wxPyBeginAllowThreads();
6902 {
6903 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6904 result = (wxPoint2D *) &_result_ref;
6905 }
6906
6907 wxPyEndAllowThreads(__tstate);
6908 if (PyErr_Occurred()) SWIG_fail;
6909 }
6910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6911 return resultobj;
6912 fail:
6913 return NULL;
6914 }
6915
6916
6917 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6918 PyObject *resultobj;
6919 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6920 wxPoint2D *arg2 = 0 ;
6921 wxPoint2D *result;
6922 wxPoint2D temp2 ;
6923 PyObject * obj0 = 0 ;
6924 PyObject * obj1 = 0 ;
6925 char *kwnames[] = {
6926 (char *) "self",(char *) "pt", NULL
6927 };
6928
6929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6931 if (SWIG_arg_fail(1)) SWIG_fail;
6932 {
6933 arg2 = &temp2;
6934 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6935 }
6936 {
6937 PyThreadState* __tstate = wxPyBeginAllowThreads();
6938 {
6939 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6940 result = (wxPoint2D *) &_result_ref;
6941 }
6942
6943 wxPyEndAllowThreads(__tstate);
6944 if (PyErr_Occurred()) SWIG_fail;
6945 }
6946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6947 return resultobj;
6948 fail:
6949 return NULL;
6950 }
6951
6952
6953 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
6954 PyObject *resultobj;
6955 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6956 wxPoint2D *arg2 = 0 ;
6957 wxPoint2D *result;
6958 wxPoint2D temp2 ;
6959 PyObject * obj0 = 0 ;
6960 PyObject * obj1 = 0 ;
6961 char *kwnames[] = {
6962 (char *) "self",(char *) "pt", NULL
6963 };
6964
6965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
6966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6967 if (SWIG_arg_fail(1)) SWIG_fail;
6968 {
6969 arg2 = &temp2;
6970 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6971 }
6972 {
6973 PyThreadState* __tstate = wxPyBeginAllowThreads();
6974 {
6975 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
6976 result = (wxPoint2D *) &_result_ref;
6977 }
6978
6979 wxPyEndAllowThreads(__tstate);
6980 if (PyErr_Occurred()) SWIG_fail;
6981 }
6982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6983 return resultobj;
6984 fail:
6985 return NULL;
6986 }
6987
6988
6989 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
6990 PyObject *resultobj;
6991 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6992 wxPoint2D *arg2 = 0 ;
6993 wxPoint2D *result;
6994 wxPoint2D temp2 ;
6995 PyObject * obj0 = 0 ;
6996 PyObject * obj1 = 0 ;
6997 char *kwnames[] = {
6998 (char *) "self",(char *) "pt", NULL
6999 };
7000
7001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7003 if (SWIG_arg_fail(1)) SWIG_fail;
7004 {
7005 arg2 = &temp2;
7006 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7007 }
7008 {
7009 PyThreadState* __tstate = wxPyBeginAllowThreads();
7010 {
7011 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7012 result = (wxPoint2D *) &_result_ref;
7013 }
7014
7015 wxPyEndAllowThreads(__tstate);
7016 if (PyErr_Occurred()) SWIG_fail;
7017 }
7018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7019 return resultobj;
7020 fail:
7021 return NULL;
7022 }
7023
7024
7025 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7026 PyObject *resultobj;
7027 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7028 wxPoint2D *arg2 = 0 ;
7029 bool result;
7030 wxPoint2D temp2 ;
7031 PyObject * obj0 = 0 ;
7032 PyObject * obj1 = 0 ;
7033 char *kwnames[] = {
7034 (char *) "self",(char *) "pt", NULL
7035 };
7036
7037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7039 if (SWIG_arg_fail(1)) SWIG_fail;
7040 {
7041 arg2 = &temp2;
7042 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7043 }
7044 {
7045 PyThreadState* __tstate = wxPyBeginAllowThreads();
7046 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7047
7048 wxPyEndAllowThreads(__tstate);
7049 if (PyErr_Occurred()) SWIG_fail;
7050 }
7051 {
7052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7053 }
7054 return resultobj;
7055 fail:
7056 return NULL;
7057 }
7058
7059
7060 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7061 PyObject *resultobj;
7062 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7063 wxPoint2D *arg2 = 0 ;
7064 bool result;
7065 wxPoint2D temp2 ;
7066 PyObject * obj0 = 0 ;
7067 PyObject * obj1 = 0 ;
7068 char *kwnames[] = {
7069 (char *) "self",(char *) "pt", NULL
7070 };
7071
7072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7074 if (SWIG_arg_fail(1)) SWIG_fail;
7075 {
7076 arg2 = &temp2;
7077 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7078 }
7079 {
7080 PyThreadState* __tstate = wxPyBeginAllowThreads();
7081 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7082
7083 wxPyEndAllowThreads(__tstate);
7084 if (PyErr_Occurred()) SWIG_fail;
7085 }
7086 {
7087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7088 }
7089 return resultobj;
7090 fail:
7091 return NULL;
7092 }
7093
7094
7095 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7096 PyObject *resultobj;
7097 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7098 double arg2 ;
7099 PyObject * obj0 = 0 ;
7100 PyObject * obj1 = 0 ;
7101 char *kwnames[] = {
7102 (char *) "self",(char *) "m_x", NULL
7103 };
7104
7105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7107 if (SWIG_arg_fail(1)) SWIG_fail;
7108 {
7109 arg2 = (double)(SWIG_As_double(obj1));
7110 if (SWIG_arg_fail(2)) SWIG_fail;
7111 }
7112 if (arg1) (arg1)->m_x = arg2;
7113
7114 Py_INCREF(Py_None); resultobj = Py_None;
7115 return resultobj;
7116 fail:
7117 return NULL;
7118 }
7119
7120
7121 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7122 PyObject *resultobj;
7123 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7124 double result;
7125 PyObject * obj0 = 0 ;
7126 char *kwnames[] = {
7127 (char *) "self", NULL
7128 };
7129
7130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7132 if (SWIG_arg_fail(1)) SWIG_fail;
7133 result = (double) ((arg1)->m_x);
7134
7135 {
7136 resultobj = SWIG_From_double((double)(result));
7137 }
7138 return resultobj;
7139 fail:
7140 return NULL;
7141 }
7142
7143
7144 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7145 PyObject *resultobj;
7146 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7147 double arg2 ;
7148 PyObject * obj0 = 0 ;
7149 PyObject * obj1 = 0 ;
7150 char *kwnames[] = {
7151 (char *) "self",(char *) "m_y", NULL
7152 };
7153
7154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7156 if (SWIG_arg_fail(1)) SWIG_fail;
7157 {
7158 arg2 = (double)(SWIG_As_double(obj1));
7159 if (SWIG_arg_fail(2)) SWIG_fail;
7160 }
7161 if (arg1) (arg1)->m_y = arg2;
7162
7163 Py_INCREF(Py_None); resultobj = Py_None;
7164 return resultobj;
7165 fail:
7166 return NULL;
7167 }
7168
7169
7170 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7171 PyObject *resultobj;
7172 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7173 double result;
7174 PyObject * obj0 = 0 ;
7175 char *kwnames[] = {
7176 (char *) "self", NULL
7177 };
7178
7179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7181 if (SWIG_arg_fail(1)) SWIG_fail;
7182 result = (double) ((arg1)->m_y);
7183
7184 {
7185 resultobj = SWIG_From_double((double)(result));
7186 }
7187 return resultobj;
7188 fail:
7189 return NULL;
7190 }
7191
7192
7193 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7194 PyObject *resultobj;
7195 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7196 double arg2 = (double) 0 ;
7197 double arg3 = (double) 0 ;
7198 PyObject * obj0 = 0 ;
7199 PyObject * obj1 = 0 ;
7200 PyObject * obj2 = 0 ;
7201 char *kwnames[] = {
7202 (char *) "self",(char *) "x",(char *) "y", NULL
7203 };
7204
7205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7207 if (SWIG_arg_fail(1)) SWIG_fail;
7208 if (obj1) {
7209 {
7210 arg2 = (double)(SWIG_As_double(obj1));
7211 if (SWIG_arg_fail(2)) SWIG_fail;
7212 }
7213 }
7214 if (obj2) {
7215 {
7216 arg3 = (double)(SWIG_As_double(obj2));
7217 if (SWIG_arg_fail(3)) SWIG_fail;
7218 }
7219 }
7220 {
7221 PyThreadState* __tstate = wxPyBeginAllowThreads();
7222 wxPoint2D_Set(arg1,arg2,arg3);
7223
7224 wxPyEndAllowThreads(__tstate);
7225 if (PyErr_Occurred()) SWIG_fail;
7226 }
7227 Py_INCREF(Py_None); resultobj = Py_None;
7228 return resultobj;
7229 fail:
7230 return NULL;
7231 }
7232
7233
7234 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7235 PyObject *resultobj;
7236 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7237 PyObject *result;
7238 PyObject * obj0 = 0 ;
7239 char *kwnames[] = {
7240 (char *) "self", NULL
7241 };
7242
7243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7245 if (SWIG_arg_fail(1)) SWIG_fail;
7246 {
7247 PyThreadState* __tstate = wxPyBeginAllowThreads();
7248 result = (PyObject *)wxPoint2D_Get(arg1);
7249
7250 wxPyEndAllowThreads(__tstate);
7251 if (PyErr_Occurred()) SWIG_fail;
7252 }
7253 resultobj = result;
7254 return resultobj;
7255 fail:
7256 return NULL;
7257 }
7258
7259
7260 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7261 PyObject *obj;
7262 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7263 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7264 Py_INCREF(obj);
7265 return Py_BuildValue((char *)"");
7266 }
7267 static int _wrap_DefaultPosition_set(PyObject *) {
7268 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7269 return 1;
7270 }
7271
7272
7273 static PyObject *_wrap_DefaultPosition_get(void) {
7274 PyObject *pyobj;
7275
7276 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7277 return pyobj;
7278 }
7279
7280
7281 static int _wrap_DefaultSize_set(PyObject *) {
7282 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7283 return 1;
7284 }
7285
7286
7287 static PyObject *_wrap_DefaultSize_get(void) {
7288 PyObject *pyobj;
7289
7290 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7291 return pyobj;
7292 }
7293
7294
7295 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7296 PyObject *resultobj;
7297 PyObject *arg1 = (PyObject *) 0 ;
7298 wxPyInputStream *result;
7299 PyObject * obj0 = 0 ;
7300 char *kwnames[] = {
7301 (char *) "p", NULL
7302 };
7303
7304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7305 arg1 = obj0;
7306 {
7307 PyThreadState* __tstate = wxPyBeginAllowThreads();
7308 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7309
7310 wxPyEndAllowThreads(__tstate);
7311 if (PyErr_Occurred()) SWIG_fail;
7312 }
7313 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7314 return resultobj;
7315 fail:
7316 return NULL;
7317 }
7318
7319
7320 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7321 PyObject *resultobj;
7322 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7323 PyObject * obj0 = 0 ;
7324 char *kwnames[] = {
7325 (char *) "self", NULL
7326 };
7327
7328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7330 if (SWIG_arg_fail(1)) SWIG_fail;
7331 {
7332 PyThreadState* __tstate = wxPyBeginAllowThreads();
7333 delete arg1;
7334
7335 wxPyEndAllowThreads(__tstate);
7336 if (PyErr_Occurred()) SWIG_fail;
7337 }
7338 Py_INCREF(Py_None); resultobj = Py_None;
7339 return resultobj;
7340 fail:
7341 return NULL;
7342 }
7343
7344
7345 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7346 PyObject *resultobj;
7347 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7348 PyObject * obj0 = 0 ;
7349 char *kwnames[] = {
7350 (char *) "self", NULL
7351 };
7352
7353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7355 if (SWIG_arg_fail(1)) SWIG_fail;
7356 {
7357 PyThreadState* __tstate = wxPyBeginAllowThreads();
7358 (arg1)->close();
7359
7360 wxPyEndAllowThreads(__tstate);
7361 if (PyErr_Occurred()) SWIG_fail;
7362 }
7363 Py_INCREF(Py_None); resultobj = Py_None;
7364 return resultobj;
7365 fail:
7366 return NULL;
7367 }
7368
7369
7370 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7371 PyObject *resultobj;
7372 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7373 PyObject * obj0 = 0 ;
7374 char *kwnames[] = {
7375 (char *) "self", NULL
7376 };
7377
7378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7380 if (SWIG_arg_fail(1)) SWIG_fail;
7381 {
7382 PyThreadState* __tstate = wxPyBeginAllowThreads();
7383 (arg1)->flush();
7384
7385 wxPyEndAllowThreads(__tstate);
7386 if (PyErr_Occurred()) SWIG_fail;
7387 }
7388 Py_INCREF(Py_None); resultobj = Py_None;
7389 return resultobj;
7390 fail:
7391 return NULL;
7392 }
7393
7394
7395 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7396 PyObject *resultobj;
7397 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7398 bool result;
7399 PyObject * obj0 = 0 ;
7400 char *kwnames[] = {
7401 (char *) "self", NULL
7402 };
7403
7404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7406 if (SWIG_arg_fail(1)) SWIG_fail;
7407 {
7408 PyThreadState* __tstate = wxPyBeginAllowThreads();
7409 result = (bool)(arg1)->eof();
7410
7411 wxPyEndAllowThreads(__tstate);
7412 if (PyErr_Occurred()) SWIG_fail;
7413 }
7414 {
7415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7416 }
7417 return resultobj;
7418 fail:
7419 return NULL;
7420 }
7421
7422
7423 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7424 PyObject *resultobj;
7425 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7426 int arg2 = (int) -1 ;
7427 PyObject *result;
7428 PyObject * obj0 = 0 ;
7429 PyObject * obj1 = 0 ;
7430 char *kwnames[] = {
7431 (char *) "self",(char *) "size", NULL
7432 };
7433
7434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7436 if (SWIG_arg_fail(1)) SWIG_fail;
7437 if (obj1) {
7438 {
7439 arg2 = (int)(SWIG_As_int(obj1));
7440 if (SWIG_arg_fail(2)) SWIG_fail;
7441 }
7442 }
7443 {
7444 PyThreadState* __tstate = wxPyBeginAllowThreads();
7445 result = (PyObject *)(arg1)->read(arg2);
7446
7447 wxPyEndAllowThreads(__tstate);
7448 if (PyErr_Occurred()) SWIG_fail;
7449 }
7450 resultobj = result;
7451 return resultobj;
7452 fail:
7453 return NULL;
7454 }
7455
7456
7457 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7458 PyObject *resultobj;
7459 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7460 int arg2 = (int) -1 ;
7461 PyObject *result;
7462 PyObject * obj0 = 0 ;
7463 PyObject * obj1 = 0 ;
7464 char *kwnames[] = {
7465 (char *) "self",(char *) "size", NULL
7466 };
7467
7468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7470 if (SWIG_arg_fail(1)) SWIG_fail;
7471 if (obj1) {
7472 {
7473 arg2 = (int)(SWIG_As_int(obj1));
7474 if (SWIG_arg_fail(2)) SWIG_fail;
7475 }
7476 }
7477 {
7478 PyThreadState* __tstate = wxPyBeginAllowThreads();
7479 result = (PyObject *)(arg1)->readline(arg2);
7480
7481 wxPyEndAllowThreads(__tstate);
7482 if (PyErr_Occurred()) SWIG_fail;
7483 }
7484 resultobj = result;
7485 return resultobj;
7486 fail:
7487 return NULL;
7488 }
7489
7490
7491 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7492 PyObject *resultobj;
7493 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7494 int arg2 = (int) -1 ;
7495 PyObject *result;
7496 PyObject * obj0 = 0 ;
7497 PyObject * obj1 = 0 ;
7498 char *kwnames[] = {
7499 (char *) "self",(char *) "sizehint", NULL
7500 };
7501
7502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7504 if (SWIG_arg_fail(1)) SWIG_fail;
7505 if (obj1) {
7506 {
7507 arg2 = (int)(SWIG_As_int(obj1));
7508 if (SWIG_arg_fail(2)) SWIG_fail;
7509 }
7510 }
7511 {
7512 PyThreadState* __tstate = wxPyBeginAllowThreads();
7513 result = (PyObject *)(arg1)->readlines(arg2);
7514
7515 wxPyEndAllowThreads(__tstate);
7516 if (PyErr_Occurred()) SWIG_fail;
7517 }
7518 resultobj = result;
7519 return resultobj;
7520 fail:
7521 return NULL;
7522 }
7523
7524
7525 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7526 PyObject *resultobj;
7527 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7528 int arg2 ;
7529 int arg3 = (int) 0 ;
7530 PyObject * obj0 = 0 ;
7531 PyObject * obj1 = 0 ;
7532 PyObject * obj2 = 0 ;
7533 char *kwnames[] = {
7534 (char *) "self",(char *) "offset",(char *) "whence", NULL
7535 };
7536
7537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7539 if (SWIG_arg_fail(1)) SWIG_fail;
7540 {
7541 arg2 = (int)(SWIG_As_int(obj1));
7542 if (SWIG_arg_fail(2)) SWIG_fail;
7543 }
7544 if (obj2) {
7545 {
7546 arg3 = (int)(SWIG_As_int(obj2));
7547 if (SWIG_arg_fail(3)) SWIG_fail;
7548 }
7549 }
7550 {
7551 PyThreadState* __tstate = wxPyBeginAllowThreads();
7552 (arg1)->seek(arg2,arg3);
7553
7554 wxPyEndAllowThreads(__tstate);
7555 if (PyErr_Occurred()) SWIG_fail;
7556 }
7557 Py_INCREF(Py_None); resultobj = Py_None;
7558 return resultobj;
7559 fail:
7560 return NULL;
7561 }
7562
7563
7564 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7565 PyObject *resultobj;
7566 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7567 int result;
7568 PyObject * obj0 = 0 ;
7569 char *kwnames[] = {
7570 (char *) "self", NULL
7571 };
7572
7573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7575 if (SWIG_arg_fail(1)) SWIG_fail;
7576 {
7577 PyThreadState* __tstate = wxPyBeginAllowThreads();
7578 result = (int)(arg1)->tell();
7579
7580 wxPyEndAllowThreads(__tstate);
7581 if (PyErr_Occurred()) SWIG_fail;
7582 }
7583 {
7584 resultobj = SWIG_From_int((int)(result));
7585 }
7586 return resultobj;
7587 fail:
7588 return NULL;
7589 }
7590
7591
7592 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7593 PyObject *resultobj;
7594 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7595 char result;
7596 PyObject * obj0 = 0 ;
7597 char *kwnames[] = {
7598 (char *) "self", NULL
7599 };
7600
7601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7603 if (SWIG_arg_fail(1)) SWIG_fail;
7604 {
7605 PyThreadState* __tstate = wxPyBeginAllowThreads();
7606 result = (char)(arg1)->Peek();
7607
7608 wxPyEndAllowThreads(__tstate);
7609 if (PyErr_Occurred()) SWIG_fail;
7610 }
7611 {
7612 resultobj = SWIG_From_char((char)(result));
7613 }
7614 return resultobj;
7615 fail:
7616 return NULL;
7617 }
7618
7619
7620 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7621 PyObject *resultobj;
7622 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7623 char result;
7624 PyObject * obj0 = 0 ;
7625 char *kwnames[] = {
7626 (char *) "self", NULL
7627 };
7628
7629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7631 if (SWIG_arg_fail(1)) SWIG_fail;
7632 {
7633 PyThreadState* __tstate = wxPyBeginAllowThreads();
7634 result = (char)(arg1)->GetC();
7635
7636 wxPyEndAllowThreads(__tstate);
7637 if (PyErr_Occurred()) SWIG_fail;
7638 }
7639 {
7640 resultobj = SWIG_From_char((char)(result));
7641 }
7642 return resultobj;
7643 fail:
7644 return NULL;
7645 }
7646
7647
7648 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7649 PyObject *resultobj;
7650 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7651 size_t result;
7652 PyObject * obj0 = 0 ;
7653 char *kwnames[] = {
7654 (char *) "self", NULL
7655 };
7656
7657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7659 if (SWIG_arg_fail(1)) SWIG_fail;
7660 {
7661 PyThreadState* __tstate = wxPyBeginAllowThreads();
7662 result = (size_t)(arg1)->LastRead();
7663
7664 wxPyEndAllowThreads(__tstate);
7665 if (PyErr_Occurred()) SWIG_fail;
7666 }
7667 {
7668 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7669 }
7670 return resultobj;
7671 fail:
7672 return NULL;
7673 }
7674
7675
7676 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7677 PyObject *resultobj;
7678 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7679 bool result;
7680 PyObject * obj0 = 0 ;
7681 char *kwnames[] = {
7682 (char *) "self", NULL
7683 };
7684
7685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7687 if (SWIG_arg_fail(1)) SWIG_fail;
7688 {
7689 PyThreadState* __tstate = wxPyBeginAllowThreads();
7690 result = (bool)(arg1)->CanRead();
7691
7692 wxPyEndAllowThreads(__tstate);
7693 if (PyErr_Occurred()) SWIG_fail;
7694 }
7695 {
7696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7697 }
7698 return resultobj;
7699 fail:
7700 return NULL;
7701 }
7702
7703
7704 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7705 PyObject *resultobj;
7706 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7707 bool result;
7708 PyObject * obj0 = 0 ;
7709 char *kwnames[] = {
7710 (char *) "self", NULL
7711 };
7712
7713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7715 if (SWIG_arg_fail(1)) SWIG_fail;
7716 {
7717 PyThreadState* __tstate = wxPyBeginAllowThreads();
7718 result = (bool)(arg1)->Eof();
7719
7720 wxPyEndAllowThreads(__tstate);
7721 if (PyErr_Occurred()) SWIG_fail;
7722 }
7723 {
7724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7725 }
7726 return resultobj;
7727 fail:
7728 return NULL;
7729 }
7730
7731
7732 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7733 PyObject *resultobj;
7734 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7735 char arg2 ;
7736 bool result;
7737 PyObject * obj0 = 0 ;
7738 PyObject * obj1 = 0 ;
7739 char *kwnames[] = {
7740 (char *) "self",(char *) "c", NULL
7741 };
7742
7743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7745 if (SWIG_arg_fail(1)) SWIG_fail;
7746 {
7747 arg2 = (char)(SWIG_As_char(obj1));
7748 if (SWIG_arg_fail(2)) SWIG_fail;
7749 }
7750 {
7751 PyThreadState* __tstate = wxPyBeginAllowThreads();
7752 result = (bool)(arg1)->Ungetch(arg2);
7753
7754 wxPyEndAllowThreads(__tstate);
7755 if (PyErr_Occurred()) SWIG_fail;
7756 }
7757 {
7758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7759 }
7760 return resultobj;
7761 fail:
7762 return NULL;
7763 }
7764
7765
7766 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7767 PyObject *resultobj;
7768 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7769 long arg2 ;
7770 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7771 long result;
7772 PyObject * obj0 = 0 ;
7773 PyObject * obj1 = 0 ;
7774 PyObject * obj2 = 0 ;
7775 char *kwnames[] = {
7776 (char *) "self",(char *) "pos",(char *) "mode", NULL
7777 };
7778
7779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7781 if (SWIG_arg_fail(1)) SWIG_fail;
7782 {
7783 arg2 = (long)(SWIG_As_long(obj1));
7784 if (SWIG_arg_fail(2)) SWIG_fail;
7785 }
7786 if (obj2) {
7787 {
7788 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7789 if (SWIG_arg_fail(3)) SWIG_fail;
7790 }
7791 }
7792 {
7793 PyThreadState* __tstate = wxPyBeginAllowThreads();
7794 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7795
7796 wxPyEndAllowThreads(__tstate);
7797 if (PyErr_Occurred()) SWIG_fail;
7798 }
7799 {
7800 resultobj = SWIG_From_long((long)(result));
7801 }
7802 return resultobj;
7803 fail:
7804 return NULL;
7805 }
7806
7807
7808 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7809 PyObject *resultobj;
7810 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7811 long result;
7812 PyObject * obj0 = 0 ;
7813 char *kwnames[] = {
7814 (char *) "self", NULL
7815 };
7816
7817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7819 if (SWIG_arg_fail(1)) SWIG_fail;
7820 {
7821 PyThreadState* __tstate = wxPyBeginAllowThreads();
7822 result = (long)(arg1)->TellI();
7823
7824 wxPyEndAllowThreads(__tstate);
7825 if (PyErr_Occurred()) SWIG_fail;
7826 }
7827 {
7828 resultobj = SWIG_From_long((long)(result));
7829 }
7830 return resultobj;
7831 fail:
7832 return NULL;
7833 }
7834
7835
7836 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7837 PyObject *obj;
7838 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7839 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7840 Py_INCREF(obj);
7841 return Py_BuildValue((char *)"");
7842 }
7843 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7844 PyObject *resultobj;
7845 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7846 PyObject *arg2 = (PyObject *) 0 ;
7847 PyObject * obj0 = 0 ;
7848 PyObject * obj1 = 0 ;
7849 char *kwnames[] = {
7850 (char *) "self",(char *) "obj", NULL
7851 };
7852
7853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7855 if (SWIG_arg_fail(1)) SWIG_fail;
7856 arg2 = obj1;
7857 {
7858 PyThreadState* __tstate = wxPyBeginAllowThreads();
7859 wxOutputStream_write(arg1,arg2);
7860
7861 wxPyEndAllowThreads(__tstate);
7862 if (PyErr_Occurred()) SWIG_fail;
7863 }
7864 Py_INCREF(Py_None); resultobj = Py_None;
7865 return resultobj;
7866 fail:
7867 return NULL;
7868 }
7869
7870
7871 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7872 PyObject *obj;
7873 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7874 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7875 Py_INCREF(obj);
7876 return Py_BuildValue((char *)"");
7877 }
7878 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7879 PyObject *resultobj;
7880 wxInputStream *arg1 = (wxInputStream *) 0 ;
7881 wxString *arg2 = 0 ;
7882 wxString *arg3 = 0 ;
7883 wxString *arg4 = 0 ;
7884 wxDateTime arg5 ;
7885 wxFSFile *result;
7886 wxPyInputStream *temp1 ;
7887 bool created1 ;
7888 bool temp2 = false ;
7889 bool temp3 = false ;
7890 bool temp4 = false ;
7891 PyObject * obj0 = 0 ;
7892 PyObject * obj1 = 0 ;
7893 PyObject * obj2 = 0 ;
7894 PyObject * obj3 = 0 ;
7895 PyObject * obj4 = 0 ;
7896 char *kwnames[] = {
7897 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7898 };
7899
7900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7901 {
7902 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7903 arg1 = temp1->m_wxis;
7904 created1 = false;
7905 } else {
7906 PyErr_Clear(); // clear the failure of the wxPyConvert above
7907 arg1 = wxPyCBInputStream_create(obj0, false);
7908 if (arg1 == NULL) {
7909 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
7910 SWIG_fail;
7911 }
7912 created1 = true;
7913 }
7914 }
7915 {
7916 arg2 = wxString_in_helper(obj1);
7917 if (arg2 == NULL) SWIG_fail;
7918 temp2 = true;
7919 }
7920 {
7921 arg3 = wxString_in_helper(obj2);
7922 if (arg3 == NULL) SWIG_fail;
7923 temp3 = true;
7924 }
7925 {
7926 arg4 = wxString_in_helper(obj3);
7927 if (arg4 == NULL) SWIG_fail;
7928 temp4 = true;
7929 }
7930 {
7931 wxDateTime * argp;
7932 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7933 if (SWIG_arg_fail(5)) SWIG_fail;
7934 if (argp == NULL) {
7935 SWIG_null_ref("wxDateTime");
7936 }
7937 if (SWIG_arg_fail(5)) SWIG_fail;
7938 arg5 = *argp;
7939 }
7940 {
7941 PyThreadState* __tstate = wxPyBeginAllowThreads();
7942 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7943
7944 wxPyEndAllowThreads(__tstate);
7945 if (PyErr_Occurred()) SWIG_fail;
7946 }
7947 {
7948 resultobj = wxPyMake_wxObject(result, 1);
7949 }
7950 {
7951 if (created1)
7952 delete arg1;
7953 }
7954 {
7955 if (temp2)
7956 delete arg2;
7957 }
7958 {
7959 if (temp3)
7960 delete arg3;
7961 }
7962 {
7963 if (temp4)
7964 delete arg4;
7965 }
7966 return resultobj;
7967 fail:
7968 {
7969 if (created1)
7970 delete arg1;
7971 }
7972 {
7973 if (temp2)
7974 delete arg2;
7975 }
7976 {
7977 if (temp3)
7978 delete arg3;
7979 }
7980 {
7981 if (temp4)
7982 delete arg4;
7983 }
7984 return NULL;
7985 }
7986
7987
7988 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7989 PyObject *resultobj;
7990 wxFSFile *arg1 = (wxFSFile *) 0 ;
7991 PyObject * obj0 = 0 ;
7992 char *kwnames[] = {
7993 (char *) "self", NULL
7994 };
7995
7996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
7997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
7998 if (SWIG_arg_fail(1)) SWIG_fail;
7999 {
8000 PyThreadState* __tstate = wxPyBeginAllowThreads();
8001 delete arg1;
8002
8003 wxPyEndAllowThreads(__tstate);
8004 if (PyErr_Occurred()) SWIG_fail;
8005 }
8006 Py_INCREF(Py_None); resultobj = Py_None;
8007 return resultobj;
8008 fail:
8009 return NULL;
8010 }
8011
8012
8013 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8014 PyObject *resultobj;
8015 wxFSFile *arg1 = (wxFSFile *) 0 ;
8016 wxInputStream *result;
8017 PyObject * obj0 = 0 ;
8018 char *kwnames[] = {
8019 (char *) "self", NULL
8020 };
8021
8022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8024 if (SWIG_arg_fail(1)) SWIG_fail;
8025 {
8026 PyThreadState* __tstate = wxPyBeginAllowThreads();
8027 result = (wxInputStream *)(arg1)->GetStream();
8028
8029 wxPyEndAllowThreads(__tstate);
8030 if (PyErr_Occurred()) SWIG_fail;
8031 }
8032 {
8033 wxPyInputStream * _ptr = NULL;
8034
8035 if (result) {
8036 _ptr = new wxPyInputStream(result);
8037 }
8038 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8039 }
8040 return resultobj;
8041 fail:
8042 return NULL;
8043 }
8044
8045
8046 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8047 PyObject *resultobj;
8048 wxFSFile *arg1 = (wxFSFile *) 0 ;
8049 wxString *result;
8050 PyObject * obj0 = 0 ;
8051 char *kwnames[] = {
8052 (char *) "self", NULL
8053 };
8054
8055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8057 if (SWIG_arg_fail(1)) SWIG_fail;
8058 {
8059 PyThreadState* __tstate = wxPyBeginAllowThreads();
8060 {
8061 wxString const &_result_ref = (arg1)->GetMimeType();
8062 result = (wxString *) &_result_ref;
8063 }
8064
8065 wxPyEndAllowThreads(__tstate);
8066 if (PyErr_Occurred()) SWIG_fail;
8067 }
8068 {
8069 #if wxUSE_UNICODE
8070 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8071 #else
8072 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8073 #endif
8074 }
8075 return resultobj;
8076 fail:
8077 return NULL;
8078 }
8079
8080
8081 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8082 PyObject *resultobj;
8083 wxFSFile *arg1 = (wxFSFile *) 0 ;
8084 wxString *result;
8085 PyObject * obj0 = 0 ;
8086 char *kwnames[] = {
8087 (char *) "self", NULL
8088 };
8089
8090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8092 if (SWIG_arg_fail(1)) SWIG_fail;
8093 {
8094 PyThreadState* __tstate = wxPyBeginAllowThreads();
8095 {
8096 wxString const &_result_ref = (arg1)->GetLocation();
8097 result = (wxString *) &_result_ref;
8098 }
8099
8100 wxPyEndAllowThreads(__tstate);
8101 if (PyErr_Occurred()) SWIG_fail;
8102 }
8103 {
8104 #if wxUSE_UNICODE
8105 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8106 #else
8107 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8108 #endif
8109 }
8110 return resultobj;
8111 fail:
8112 return NULL;
8113 }
8114
8115
8116 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8117 PyObject *resultobj;
8118 wxFSFile *arg1 = (wxFSFile *) 0 ;
8119 wxString *result;
8120 PyObject * obj0 = 0 ;
8121 char *kwnames[] = {
8122 (char *) "self", NULL
8123 };
8124
8125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8127 if (SWIG_arg_fail(1)) SWIG_fail;
8128 {
8129 PyThreadState* __tstate = wxPyBeginAllowThreads();
8130 {
8131 wxString const &_result_ref = (arg1)->GetAnchor();
8132 result = (wxString *) &_result_ref;
8133 }
8134
8135 wxPyEndAllowThreads(__tstate);
8136 if (PyErr_Occurred()) SWIG_fail;
8137 }
8138 {
8139 #if wxUSE_UNICODE
8140 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8141 #else
8142 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8143 #endif
8144 }
8145 return resultobj;
8146 fail:
8147 return NULL;
8148 }
8149
8150
8151 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8152 PyObject *resultobj;
8153 wxFSFile *arg1 = (wxFSFile *) 0 ;
8154 wxDateTime result;
8155 PyObject * obj0 = 0 ;
8156 char *kwnames[] = {
8157 (char *) "self", NULL
8158 };
8159
8160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8162 if (SWIG_arg_fail(1)) SWIG_fail;
8163 {
8164 PyThreadState* __tstate = wxPyBeginAllowThreads();
8165 result = (arg1)->GetModificationTime();
8166
8167 wxPyEndAllowThreads(__tstate);
8168 if (PyErr_Occurred()) SWIG_fail;
8169 }
8170 {
8171 wxDateTime * resultptr;
8172 resultptr = new wxDateTime((wxDateTime &)(result));
8173 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8174 }
8175 return resultobj;
8176 fail:
8177 return NULL;
8178 }
8179
8180
8181 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8182 PyObject *obj;
8183 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8184 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8185 Py_INCREF(obj);
8186 return Py_BuildValue((char *)"");
8187 }
8188 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8189 PyObject *obj;
8190 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8191 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8192 Py_INCREF(obj);
8193 return Py_BuildValue((char *)"");
8194 }
8195 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8196 PyObject *resultobj;
8197 wxPyFileSystemHandler *result;
8198 char *kwnames[] = {
8199 NULL
8200 };
8201
8202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8203 {
8204 PyThreadState* __tstate = wxPyBeginAllowThreads();
8205 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8206
8207 wxPyEndAllowThreads(__tstate);
8208 if (PyErr_Occurred()) SWIG_fail;
8209 }
8210 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8211 return resultobj;
8212 fail:
8213 return NULL;
8214 }
8215
8216
8217 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8218 PyObject *resultobj;
8219 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8220 PyObject *arg2 = (PyObject *) 0 ;
8221 PyObject *arg3 = (PyObject *) 0 ;
8222 PyObject * obj0 = 0 ;
8223 PyObject * obj1 = 0 ;
8224 PyObject * obj2 = 0 ;
8225 char *kwnames[] = {
8226 (char *) "self",(char *) "self",(char *) "_class", NULL
8227 };
8228
8229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8231 if (SWIG_arg_fail(1)) SWIG_fail;
8232 arg2 = obj1;
8233 arg3 = obj2;
8234 {
8235 PyThreadState* __tstate = wxPyBeginAllowThreads();
8236 (arg1)->_setCallbackInfo(arg2,arg3);
8237
8238 wxPyEndAllowThreads(__tstate);
8239 if (PyErr_Occurred()) SWIG_fail;
8240 }
8241 Py_INCREF(Py_None); resultobj = Py_None;
8242 return resultobj;
8243 fail:
8244 return NULL;
8245 }
8246
8247
8248 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8249 PyObject *resultobj;
8250 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8251 wxString *arg2 = 0 ;
8252 bool result;
8253 bool temp2 = false ;
8254 PyObject * obj0 = 0 ;
8255 PyObject * obj1 = 0 ;
8256 char *kwnames[] = {
8257 (char *) "self",(char *) "location", NULL
8258 };
8259
8260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8262 if (SWIG_arg_fail(1)) SWIG_fail;
8263 {
8264 arg2 = wxString_in_helper(obj1);
8265 if (arg2 == NULL) SWIG_fail;
8266 temp2 = true;
8267 }
8268 {
8269 PyThreadState* __tstate = wxPyBeginAllowThreads();
8270 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8271
8272 wxPyEndAllowThreads(__tstate);
8273 if (PyErr_Occurred()) SWIG_fail;
8274 }
8275 {
8276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8277 }
8278 {
8279 if (temp2)
8280 delete arg2;
8281 }
8282 return resultobj;
8283 fail:
8284 {
8285 if (temp2)
8286 delete arg2;
8287 }
8288 return NULL;
8289 }
8290
8291
8292 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8293 PyObject *resultobj;
8294 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8295 wxFileSystem *arg2 = 0 ;
8296 wxString *arg3 = 0 ;
8297 wxFSFile *result;
8298 bool temp3 = false ;
8299 PyObject * obj0 = 0 ;
8300 PyObject * obj1 = 0 ;
8301 PyObject * obj2 = 0 ;
8302 char *kwnames[] = {
8303 (char *) "self",(char *) "fs",(char *) "location", NULL
8304 };
8305
8306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8308 if (SWIG_arg_fail(1)) SWIG_fail;
8309 {
8310 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8311 if (SWIG_arg_fail(2)) SWIG_fail;
8312 if (arg2 == NULL) {
8313 SWIG_null_ref("wxFileSystem");
8314 }
8315 if (SWIG_arg_fail(2)) SWIG_fail;
8316 }
8317 {
8318 arg3 = wxString_in_helper(obj2);
8319 if (arg3 == NULL) SWIG_fail;
8320 temp3 = true;
8321 }
8322 {
8323 PyThreadState* __tstate = wxPyBeginAllowThreads();
8324 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8325
8326 wxPyEndAllowThreads(__tstate);
8327 if (PyErr_Occurred()) SWIG_fail;
8328 }
8329 {
8330 resultobj = wxPyMake_wxObject(result, 1);
8331 }
8332 {
8333 if (temp3)
8334 delete arg3;
8335 }
8336 return resultobj;
8337 fail:
8338 {
8339 if (temp3)
8340 delete arg3;
8341 }
8342 return NULL;
8343 }
8344
8345
8346 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8347 PyObject *resultobj;
8348 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8349 wxString *arg2 = 0 ;
8350 int arg3 = (int) 0 ;
8351 wxString result;
8352 bool temp2 = false ;
8353 PyObject * obj0 = 0 ;
8354 PyObject * obj1 = 0 ;
8355 PyObject * obj2 = 0 ;
8356 char *kwnames[] = {
8357 (char *) "self",(char *) "spec",(char *) "flags", NULL
8358 };
8359
8360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8362 if (SWIG_arg_fail(1)) SWIG_fail;
8363 {
8364 arg2 = wxString_in_helper(obj1);
8365 if (arg2 == NULL) SWIG_fail;
8366 temp2 = true;
8367 }
8368 if (obj2) {
8369 {
8370 arg3 = (int)(SWIG_As_int(obj2));
8371 if (SWIG_arg_fail(3)) SWIG_fail;
8372 }
8373 }
8374 {
8375 PyThreadState* __tstate = wxPyBeginAllowThreads();
8376 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8377
8378 wxPyEndAllowThreads(__tstate);
8379 if (PyErr_Occurred()) SWIG_fail;
8380 }
8381 {
8382 #if wxUSE_UNICODE
8383 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8384 #else
8385 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8386 #endif
8387 }
8388 {
8389 if (temp2)
8390 delete arg2;
8391 }
8392 return resultobj;
8393 fail:
8394 {
8395 if (temp2)
8396 delete arg2;
8397 }
8398 return NULL;
8399 }
8400
8401
8402 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8403 PyObject *resultobj;
8404 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8405 wxString result;
8406 PyObject * obj0 = 0 ;
8407 char *kwnames[] = {
8408 (char *) "self", NULL
8409 };
8410
8411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8413 if (SWIG_arg_fail(1)) SWIG_fail;
8414 {
8415 PyThreadState* __tstate = wxPyBeginAllowThreads();
8416 result = (arg1)->FindNext();
8417
8418 wxPyEndAllowThreads(__tstate);
8419 if (PyErr_Occurred()) SWIG_fail;
8420 }
8421 {
8422 #if wxUSE_UNICODE
8423 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8424 #else
8425 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8426 #endif
8427 }
8428 return resultobj;
8429 fail:
8430 return NULL;
8431 }
8432
8433
8434 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8435 PyObject *resultobj;
8436 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8437 wxString *arg2 = 0 ;
8438 wxString result;
8439 bool temp2 = false ;
8440 PyObject * obj0 = 0 ;
8441 PyObject * obj1 = 0 ;
8442 char *kwnames[] = {
8443 (char *) "self",(char *) "location", NULL
8444 };
8445
8446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8448 if (SWIG_arg_fail(1)) SWIG_fail;
8449 {
8450 arg2 = wxString_in_helper(obj1);
8451 if (arg2 == NULL) SWIG_fail;
8452 temp2 = true;
8453 }
8454 {
8455 PyThreadState* __tstate = wxPyBeginAllowThreads();
8456 result = (arg1)->GetProtocol((wxString const &)*arg2);
8457
8458 wxPyEndAllowThreads(__tstate);
8459 if (PyErr_Occurred()) SWIG_fail;
8460 }
8461 {
8462 #if wxUSE_UNICODE
8463 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8464 #else
8465 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8466 #endif
8467 }
8468 {
8469 if (temp2)
8470 delete arg2;
8471 }
8472 return resultobj;
8473 fail:
8474 {
8475 if (temp2)
8476 delete arg2;
8477 }
8478 return NULL;
8479 }
8480
8481
8482 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8483 PyObject *resultobj;
8484 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8485 wxString *arg2 = 0 ;
8486 wxString result;
8487 bool temp2 = false ;
8488 PyObject * obj0 = 0 ;
8489 PyObject * obj1 = 0 ;
8490 char *kwnames[] = {
8491 (char *) "self",(char *) "location", NULL
8492 };
8493
8494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8496 if (SWIG_arg_fail(1)) SWIG_fail;
8497 {
8498 arg2 = wxString_in_helper(obj1);
8499 if (arg2 == NULL) SWIG_fail;
8500 temp2 = true;
8501 }
8502 {
8503 PyThreadState* __tstate = wxPyBeginAllowThreads();
8504 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8505
8506 wxPyEndAllowThreads(__tstate);
8507 if (PyErr_Occurred()) SWIG_fail;
8508 }
8509 {
8510 #if wxUSE_UNICODE
8511 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8512 #else
8513 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8514 #endif
8515 }
8516 {
8517 if (temp2)
8518 delete arg2;
8519 }
8520 return resultobj;
8521 fail:
8522 {
8523 if (temp2)
8524 delete arg2;
8525 }
8526 return NULL;
8527 }
8528
8529
8530 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8531 PyObject *resultobj;
8532 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8533 wxString *arg2 = 0 ;
8534 wxString result;
8535 bool temp2 = false ;
8536 PyObject * obj0 = 0 ;
8537 PyObject * obj1 = 0 ;
8538 char *kwnames[] = {
8539 (char *) "self",(char *) "location", NULL
8540 };
8541
8542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8544 if (SWIG_arg_fail(1)) SWIG_fail;
8545 {
8546 arg2 = wxString_in_helper(obj1);
8547 if (arg2 == NULL) SWIG_fail;
8548 temp2 = true;
8549 }
8550 {
8551 PyThreadState* __tstate = wxPyBeginAllowThreads();
8552 result = (arg1)->GetAnchor((wxString const &)*arg2);
8553
8554 wxPyEndAllowThreads(__tstate);
8555 if (PyErr_Occurred()) SWIG_fail;
8556 }
8557 {
8558 #if wxUSE_UNICODE
8559 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8560 #else
8561 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8562 #endif
8563 }
8564 {
8565 if (temp2)
8566 delete arg2;
8567 }
8568 return resultobj;
8569 fail:
8570 {
8571 if (temp2)
8572 delete arg2;
8573 }
8574 return NULL;
8575 }
8576
8577
8578 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8579 PyObject *resultobj;
8580 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8581 wxString *arg2 = 0 ;
8582 wxString result;
8583 bool temp2 = false ;
8584 PyObject * obj0 = 0 ;
8585 PyObject * obj1 = 0 ;
8586 char *kwnames[] = {
8587 (char *) "self",(char *) "location", NULL
8588 };
8589
8590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8592 if (SWIG_arg_fail(1)) SWIG_fail;
8593 {
8594 arg2 = wxString_in_helper(obj1);
8595 if (arg2 == NULL) SWIG_fail;
8596 temp2 = true;
8597 }
8598 {
8599 PyThreadState* __tstate = wxPyBeginAllowThreads();
8600 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8601
8602 wxPyEndAllowThreads(__tstate);
8603 if (PyErr_Occurred()) SWIG_fail;
8604 }
8605 {
8606 #if wxUSE_UNICODE
8607 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8608 #else
8609 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8610 #endif
8611 }
8612 {
8613 if (temp2)
8614 delete arg2;
8615 }
8616 return resultobj;
8617 fail:
8618 {
8619 if (temp2)
8620 delete arg2;
8621 }
8622 return NULL;
8623 }
8624
8625
8626 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8627 PyObject *resultobj;
8628 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8629 wxString *arg2 = 0 ;
8630 wxString result;
8631 bool temp2 = false ;
8632 PyObject * obj0 = 0 ;
8633 PyObject * obj1 = 0 ;
8634 char *kwnames[] = {
8635 (char *) "self",(char *) "location", NULL
8636 };
8637
8638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8640 if (SWIG_arg_fail(1)) SWIG_fail;
8641 {
8642 arg2 = wxString_in_helper(obj1);
8643 if (arg2 == NULL) SWIG_fail;
8644 temp2 = true;
8645 }
8646 {
8647 PyThreadState* __tstate = wxPyBeginAllowThreads();
8648 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8649
8650 wxPyEndAllowThreads(__tstate);
8651 if (PyErr_Occurred()) SWIG_fail;
8652 }
8653 {
8654 #if wxUSE_UNICODE
8655 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8656 #else
8657 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8658 #endif
8659 }
8660 {
8661 if (temp2)
8662 delete arg2;
8663 }
8664 return resultobj;
8665 fail:
8666 {
8667 if (temp2)
8668 delete arg2;
8669 }
8670 return NULL;
8671 }
8672
8673
8674 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8675 PyObject *obj;
8676 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8677 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8678 Py_INCREF(obj);
8679 return Py_BuildValue((char *)"");
8680 }
8681 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8682 PyObject *resultobj;
8683 wxFileSystem *result;
8684 char *kwnames[] = {
8685 NULL
8686 };
8687
8688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8689 {
8690 PyThreadState* __tstate = wxPyBeginAllowThreads();
8691 result = (wxFileSystem *)new wxFileSystem();
8692
8693 wxPyEndAllowThreads(__tstate);
8694 if (PyErr_Occurred()) SWIG_fail;
8695 }
8696 {
8697 resultobj = wxPyMake_wxObject(result, 1);
8698 }
8699 return resultobj;
8700 fail:
8701 return NULL;
8702 }
8703
8704
8705 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8706 PyObject *resultobj;
8707 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8708 PyObject * obj0 = 0 ;
8709 char *kwnames[] = {
8710 (char *) "self", NULL
8711 };
8712
8713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8715 if (SWIG_arg_fail(1)) SWIG_fail;
8716 {
8717 PyThreadState* __tstate = wxPyBeginAllowThreads();
8718 delete arg1;
8719
8720 wxPyEndAllowThreads(__tstate);
8721 if (PyErr_Occurred()) SWIG_fail;
8722 }
8723 Py_INCREF(Py_None); resultobj = Py_None;
8724 return resultobj;
8725 fail:
8726 return NULL;
8727 }
8728
8729
8730 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8731 PyObject *resultobj;
8732 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8733 wxString *arg2 = 0 ;
8734 bool arg3 = (bool) false ;
8735 bool temp2 = false ;
8736 PyObject * obj0 = 0 ;
8737 PyObject * obj1 = 0 ;
8738 PyObject * obj2 = 0 ;
8739 char *kwnames[] = {
8740 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8741 };
8742
8743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8745 if (SWIG_arg_fail(1)) SWIG_fail;
8746 {
8747 arg2 = wxString_in_helper(obj1);
8748 if (arg2 == NULL) SWIG_fail;
8749 temp2 = true;
8750 }
8751 if (obj2) {
8752 {
8753 arg3 = (bool)(SWIG_As_bool(obj2));
8754 if (SWIG_arg_fail(3)) SWIG_fail;
8755 }
8756 }
8757 {
8758 PyThreadState* __tstate = wxPyBeginAllowThreads();
8759 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8760
8761 wxPyEndAllowThreads(__tstate);
8762 if (PyErr_Occurred()) SWIG_fail;
8763 }
8764 Py_INCREF(Py_None); resultobj = Py_None;
8765 {
8766 if (temp2)
8767 delete arg2;
8768 }
8769 return resultobj;
8770 fail:
8771 {
8772 if (temp2)
8773 delete arg2;
8774 }
8775 return NULL;
8776 }
8777
8778
8779 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8780 PyObject *resultobj;
8781 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8782 wxString result;
8783 PyObject * obj0 = 0 ;
8784 char *kwnames[] = {
8785 (char *) "self", NULL
8786 };
8787
8788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8790 if (SWIG_arg_fail(1)) SWIG_fail;
8791 {
8792 PyThreadState* __tstate = wxPyBeginAllowThreads();
8793 result = (arg1)->GetPath();
8794
8795 wxPyEndAllowThreads(__tstate);
8796 if (PyErr_Occurred()) SWIG_fail;
8797 }
8798 {
8799 #if wxUSE_UNICODE
8800 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8801 #else
8802 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8803 #endif
8804 }
8805 return resultobj;
8806 fail:
8807 return NULL;
8808 }
8809
8810
8811 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8812 PyObject *resultobj;
8813 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8814 wxString *arg2 = 0 ;
8815 wxFSFile *result;
8816 bool temp2 = false ;
8817 PyObject * obj0 = 0 ;
8818 PyObject * obj1 = 0 ;
8819 char *kwnames[] = {
8820 (char *) "self",(char *) "location", NULL
8821 };
8822
8823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8825 if (SWIG_arg_fail(1)) SWIG_fail;
8826 {
8827 arg2 = wxString_in_helper(obj1);
8828 if (arg2 == NULL) SWIG_fail;
8829 temp2 = true;
8830 }
8831 {
8832 PyThreadState* __tstate = wxPyBeginAllowThreads();
8833 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8834
8835 wxPyEndAllowThreads(__tstate);
8836 if (PyErr_Occurred()) SWIG_fail;
8837 }
8838 {
8839 resultobj = wxPyMake_wxObject(result, 1);
8840 }
8841 {
8842 if (temp2)
8843 delete arg2;
8844 }
8845 return resultobj;
8846 fail:
8847 {
8848 if (temp2)
8849 delete arg2;
8850 }
8851 return NULL;
8852 }
8853
8854
8855 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8856 PyObject *resultobj;
8857 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8858 wxString *arg2 = 0 ;
8859 int arg3 = (int) 0 ;
8860 wxString result;
8861 bool temp2 = false ;
8862 PyObject * obj0 = 0 ;
8863 PyObject * obj1 = 0 ;
8864 PyObject * obj2 = 0 ;
8865 char *kwnames[] = {
8866 (char *) "self",(char *) "spec",(char *) "flags", NULL
8867 };
8868
8869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8871 if (SWIG_arg_fail(1)) SWIG_fail;
8872 {
8873 arg2 = wxString_in_helper(obj1);
8874 if (arg2 == NULL) SWIG_fail;
8875 temp2 = true;
8876 }
8877 if (obj2) {
8878 {
8879 arg3 = (int)(SWIG_As_int(obj2));
8880 if (SWIG_arg_fail(3)) SWIG_fail;
8881 }
8882 }
8883 {
8884 PyThreadState* __tstate = wxPyBeginAllowThreads();
8885 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8886
8887 wxPyEndAllowThreads(__tstate);
8888 if (PyErr_Occurred()) SWIG_fail;
8889 }
8890 {
8891 #if wxUSE_UNICODE
8892 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8893 #else
8894 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8895 #endif
8896 }
8897 {
8898 if (temp2)
8899 delete arg2;
8900 }
8901 return resultobj;
8902 fail:
8903 {
8904 if (temp2)
8905 delete arg2;
8906 }
8907 return NULL;
8908 }
8909
8910
8911 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8912 PyObject *resultobj;
8913 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8914 wxString result;
8915 PyObject * obj0 = 0 ;
8916 char *kwnames[] = {
8917 (char *) "self", NULL
8918 };
8919
8920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8922 if (SWIG_arg_fail(1)) SWIG_fail;
8923 {
8924 PyThreadState* __tstate = wxPyBeginAllowThreads();
8925 result = (arg1)->FindNext();
8926
8927 wxPyEndAllowThreads(__tstate);
8928 if (PyErr_Occurred()) SWIG_fail;
8929 }
8930 {
8931 #if wxUSE_UNICODE
8932 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8933 #else
8934 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8935 #endif
8936 }
8937 return resultobj;
8938 fail:
8939 return NULL;
8940 }
8941
8942
8943 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8944 PyObject *resultobj;
8945 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8946 PyObject * obj0 = 0 ;
8947 char *kwnames[] = {
8948 (char *) "handler", NULL
8949 };
8950
8951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8953 if (SWIG_arg_fail(1)) SWIG_fail;
8954 {
8955 PyThreadState* __tstate = wxPyBeginAllowThreads();
8956 wxFileSystem::AddHandler(arg1);
8957
8958 wxPyEndAllowThreads(__tstate);
8959 if (PyErr_Occurred()) SWIG_fail;
8960 }
8961 Py_INCREF(Py_None); resultobj = Py_None;
8962 return resultobj;
8963 fail:
8964 return NULL;
8965 }
8966
8967
8968 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
8969 PyObject *resultobj;
8970 char *kwnames[] = {
8971 NULL
8972 };
8973
8974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
8975 {
8976 PyThreadState* __tstate = wxPyBeginAllowThreads();
8977 wxFileSystem::CleanUpHandlers();
8978
8979 wxPyEndAllowThreads(__tstate);
8980 if (PyErr_Occurred()) SWIG_fail;
8981 }
8982 Py_INCREF(Py_None); resultobj = Py_None;
8983 return resultobj;
8984 fail:
8985 return NULL;
8986 }
8987
8988
8989 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
8990 PyObject *resultobj;
8991 wxString *arg1 = 0 ;
8992 wxString result;
8993 bool temp1 = false ;
8994 PyObject * obj0 = 0 ;
8995 char *kwnames[] = {
8996 (char *) "filename", NULL
8997 };
8998
8999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9000 {
9001 arg1 = wxString_in_helper(obj0);
9002 if (arg1 == NULL) SWIG_fail;
9003 temp1 = true;
9004 }
9005 {
9006 PyThreadState* __tstate = wxPyBeginAllowThreads();
9007 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9008
9009 wxPyEndAllowThreads(__tstate);
9010 if (PyErr_Occurred()) SWIG_fail;
9011 }
9012 {
9013 #if wxUSE_UNICODE
9014 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9015 #else
9016 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9017 #endif
9018 }
9019 {
9020 if (temp1)
9021 delete arg1;
9022 }
9023 return resultobj;
9024 fail:
9025 {
9026 if (temp1)
9027 delete arg1;
9028 }
9029 return NULL;
9030 }
9031
9032
9033 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9034 PyObject *resultobj;
9035 wxString *arg1 = 0 ;
9036 wxString result;
9037 bool temp1 = false ;
9038 PyObject * obj0 = 0 ;
9039 char *kwnames[] = {
9040 (char *) "url", NULL
9041 };
9042
9043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9044 {
9045 arg1 = wxString_in_helper(obj0);
9046 if (arg1 == NULL) SWIG_fail;
9047 temp1 = true;
9048 }
9049 {
9050 PyThreadState* __tstate = wxPyBeginAllowThreads();
9051 result = FileSystem_URLToFileName((wxString const &)*arg1);
9052
9053 wxPyEndAllowThreads(__tstate);
9054 if (PyErr_Occurred()) SWIG_fail;
9055 }
9056 {
9057 #if wxUSE_UNICODE
9058 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9059 #else
9060 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9061 #endif
9062 }
9063 {
9064 if (temp1)
9065 delete arg1;
9066 }
9067 return resultobj;
9068 fail:
9069 {
9070 if (temp1)
9071 delete arg1;
9072 }
9073 return NULL;
9074 }
9075
9076
9077 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9078 PyObject *obj;
9079 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9080 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9081 Py_INCREF(obj);
9082 return Py_BuildValue((char *)"");
9083 }
9084 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9085 PyObject *resultobj;
9086 wxInternetFSHandler *result;
9087 char *kwnames[] = {
9088 NULL
9089 };
9090
9091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9092 {
9093 PyThreadState* __tstate = wxPyBeginAllowThreads();
9094 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9095
9096 wxPyEndAllowThreads(__tstate);
9097 if (PyErr_Occurred()) SWIG_fail;
9098 }
9099 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9100 return resultobj;
9101 fail:
9102 return NULL;
9103 }
9104
9105
9106 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9107 PyObject *resultobj;
9108 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9109 wxString *arg2 = 0 ;
9110 bool result;
9111 bool temp2 = false ;
9112 PyObject * obj0 = 0 ;
9113 PyObject * obj1 = 0 ;
9114 char *kwnames[] = {
9115 (char *) "self",(char *) "location", NULL
9116 };
9117
9118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9120 if (SWIG_arg_fail(1)) SWIG_fail;
9121 {
9122 arg2 = wxString_in_helper(obj1);
9123 if (arg2 == NULL) SWIG_fail;
9124 temp2 = true;
9125 }
9126 {
9127 PyThreadState* __tstate = wxPyBeginAllowThreads();
9128 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9129
9130 wxPyEndAllowThreads(__tstate);
9131 if (PyErr_Occurred()) SWIG_fail;
9132 }
9133 {
9134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9135 }
9136 {
9137 if (temp2)
9138 delete arg2;
9139 }
9140 return resultobj;
9141 fail:
9142 {
9143 if (temp2)
9144 delete arg2;
9145 }
9146 return NULL;
9147 }
9148
9149
9150 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9151 PyObject *resultobj;
9152 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9153 wxFileSystem *arg2 = 0 ;
9154 wxString *arg3 = 0 ;
9155 wxFSFile *result;
9156 bool temp3 = false ;
9157 PyObject * obj0 = 0 ;
9158 PyObject * obj1 = 0 ;
9159 PyObject * obj2 = 0 ;
9160 char *kwnames[] = {
9161 (char *) "self",(char *) "fs",(char *) "location", NULL
9162 };
9163
9164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9166 if (SWIG_arg_fail(1)) SWIG_fail;
9167 {
9168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9169 if (SWIG_arg_fail(2)) SWIG_fail;
9170 if (arg2 == NULL) {
9171 SWIG_null_ref("wxFileSystem");
9172 }
9173 if (SWIG_arg_fail(2)) SWIG_fail;
9174 }
9175 {
9176 arg3 = wxString_in_helper(obj2);
9177 if (arg3 == NULL) SWIG_fail;
9178 temp3 = true;
9179 }
9180 {
9181 PyThreadState* __tstate = wxPyBeginAllowThreads();
9182 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9183
9184 wxPyEndAllowThreads(__tstate);
9185 if (PyErr_Occurred()) SWIG_fail;
9186 }
9187 {
9188 resultobj = wxPyMake_wxObject(result, 1);
9189 }
9190 {
9191 if (temp3)
9192 delete arg3;
9193 }
9194 return resultobj;
9195 fail:
9196 {
9197 if (temp3)
9198 delete arg3;
9199 }
9200 return NULL;
9201 }
9202
9203
9204 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9205 PyObject *obj;
9206 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9207 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9208 Py_INCREF(obj);
9209 return Py_BuildValue((char *)"");
9210 }
9211 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9212 PyObject *resultobj;
9213 wxZipFSHandler *result;
9214 char *kwnames[] = {
9215 NULL
9216 };
9217
9218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9219 {
9220 PyThreadState* __tstate = wxPyBeginAllowThreads();
9221 result = (wxZipFSHandler *)new wxZipFSHandler();
9222
9223 wxPyEndAllowThreads(__tstate);
9224 if (PyErr_Occurred()) SWIG_fail;
9225 }
9226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9227 return resultobj;
9228 fail:
9229 return NULL;
9230 }
9231
9232
9233 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9234 PyObject *resultobj;
9235 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9236 wxString *arg2 = 0 ;
9237 bool result;
9238 bool temp2 = false ;
9239 PyObject * obj0 = 0 ;
9240 PyObject * obj1 = 0 ;
9241 char *kwnames[] = {
9242 (char *) "self",(char *) "location", NULL
9243 };
9244
9245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9247 if (SWIG_arg_fail(1)) SWIG_fail;
9248 {
9249 arg2 = wxString_in_helper(obj1);
9250 if (arg2 == NULL) SWIG_fail;
9251 temp2 = true;
9252 }
9253 {
9254 PyThreadState* __tstate = wxPyBeginAllowThreads();
9255 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9256
9257 wxPyEndAllowThreads(__tstate);
9258 if (PyErr_Occurred()) SWIG_fail;
9259 }
9260 {
9261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9262 }
9263 {
9264 if (temp2)
9265 delete arg2;
9266 }
9267 return resultobj;
9268 fail:
9269 {
9270 if (temp2)
9271 delete arg2;
9272 }
9273 return NULL;
9274 }
9275
9276
9277 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9278 PyObject *resultobj;
9279 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9280 wxFileSystem *arg2 = 0 ;
9281 wxString *arg3 = 0 ;
9282 wxFSFile *result;
9283 bool temp3 = false ;
9284 PyObject * obj0 = 0 ;
9285 PyObject * obj1 = 0 ;
9286 PyObject * obj2 = 0 ;
9287 char *kwnames[] = {
9288 (char *) "self",(char *) "fs",(char *) "location", NULL
9289 };
9290
9291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9293 if (SWIG_arg_fail(1)) SWIG_fail;
9294 {
9295 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9296 if (SWIG_arg_fail(2)) SWIG_fail;
9297 if (arg2 == NULL) {
9298 SWIG_null_ref("wxFileSystem");
9299 }
9300 if (SWIG_arg_fail(2)) SWIG_fail;
9301 }
9302 {
9303 arg3 = wxString_in_helper(obj2);
9304 if (arg3 == NULL) SWIG_fail;
9305 temp3 = true;
9306 }
9307 {
9308 PyThreadState* __tstate = wxPyBeginAllowThreads();
9309 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9310
9311 wxPyEndAllowThreads(__tstate);
9312 if (PyErr_Occurred()) SWIG_fail;
9313 }
9314 {
9315 resultobj = wxPyMake_wxObject(result, 1);
9316 }
9317 {
9318 if (temp3)
9319 delete arg3;
9320 }
9321 return resultobj;
9322 fail:
9323 {
9324 if (temp3)
9325 delete arg3;
9326 }
9327 return NULL;
9328 }
9329
9330
9331 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9332 PyObject *resultobj;
9333 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9334 wxString *arg2 = 0 ;
9335 int arg3 = (int) 0 ;
9336 wxString result;
9337 bool temp2 = false ;
9338 PyObject * obj0 = 0 ;
9339 PyObject * obj1 = 0 ;
9340 PyObject * obj2 = 0 ;
9341 char *kwnames[] = {
9342 (char *) "self",(char *) "spec",(char *) "flags", NULL
9343 };
9344
9345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9347 if (SWIG_arg_fail(1)) SWIG_fail;
9348 {
9349 arg2 = wxString_in_helper(obj1);
9350 if (arg2 == NULL) SWIG_fail;
9351 temp2 = true;
9352 }
9353 if (obj2) {
9354 {
9355 arg3 = (int)(SWIG_As_int(obj2));
9356 if (SWIG_arg_fail(3)) SWIG_fail;
9357 }
9358 }
9359 {
9360 PyThreadState* __tstate = wxPyBeginAllowThreads();
9361 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9362
9363 wxPyEndAllowThreads(__tstate);
9364 if (PyErr_Occurred()) SWIG_fail;
9365 }
9366 {
9367 #if wxUSE_UNICODE
9368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9369 #else
9370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9371 #endif
9372 }
9373 {
9374 if (temp2)
9375 delete arg2;
9376 }
9377 return resultobj;
9378 fail:
9379 {
9380 if (temp2)
9381 delete arg2;
9382 }
9383 return NULL;
9384 }
9385
9386
9387 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9388 PyObject *resultobj;
9389 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9390 wxString result;
9391 PyObject * obj0 = 0 ;
9392 char *kwnames[] = {
9393 (char *) "self", NULL
9394 };
9395
9396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9398 if (SWIG_arg_fail(1)) SWIG_fail;
9399 {
9400 PyThreadState* __tstate = wxPyBeginAllowThreads();
9401 result = (arg1)->FindNext();
9402
9403 wxPyEndAllowThreads(__tstate);
9404 if (PyErr_Occurred()) SWIG_fail;
9405 }
9406 {
9407 #if wxUSE_UNICODE
9408 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9409 #else
9410 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9411 #endif
9412 }
9413 return resultobj;
9414 fail:
9415 return NULL;
9416 }
9417
9418
9419 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9420 PyObject *obj;
9421 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9422 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9423 Py_INCREF(obj);
9424 return Py_BuildValue((char *)"");
9425 }
9426 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9427 PyObject *resultobj;
9428 wxString *arg1 = 0 ;
9429 wxImage *arg2 = 0 ;
9430 long arg3 ;
9431 bool temp1 = false ;
9432 PyObject * obj0 = 0 ;
9433 PyObject * obj1 = 0 ;
9434 PyObject * obj2 = 0 ;
9435 char *kwnames[] = {
9436 (char *) "filename",(char *) "image",(char *) "type", NULL
9437 };
9438
9439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9440 {
9441 arg1 = wxString_in_helper(obj0);
9442 if (arg1 == NULL) SWIG_fail;
9443 temp1 = true;
9444 }
9445 {
9446 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9447 if (SWIG_arg_fail(2)) SWIG_fail;
9448 if (arg2 == NULL) {
9449 SWIG_null_ref("wxImage");
9450 }
9451 if (SWIG_arg_fail(2)) SWIG_fail;
9452 }
9453 {
9454 arg3 = (long)(SWIG_As_long(obj2));
9455 if (SWIG_arg_fail(3)) SWIG_fail;
9456 }
9457 {
9458 PyThreadState* __tstate = wxPyBeginAllowThreads();
9459 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9460
9461 wxPyEndAllowThreads(__tstate);
9462 if (PyErr_Occurred()) SWIG_fail;
9463 }
9464 Py_INCREF(Py_None); resultobj = Py_None;
9465 {
9466 if (temp1)
9467 delete arg1;
9468 }
9469 return resultobj;
9470 fail:
9471 {
9472 if (temp1)
9473 delete arg1;
9474 }
9475 return NULL;
9476 }
9477
9478
9479 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9480 PyObject *resultobj;
9481 wxString *arg1 = 0 ;
9482 wxBitmap *arg2 = 0 ;
9483 long arg3 ;
9484 bool temp1 = false ;
9485 PyObject * obj0 = 0 ;
9486 PyObject * obj1 = 0 ;
9487 PyObject * obj2 = 0 ;
9488 char *kwnames[] = {
9489 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9490 };
9491
9492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9493 {
9494 arg1 = wxString_in_helper(obj0);
9495 if (arg1 == NULL) SWIG_fail;
9496 temp1 = true;
9497 }
9498 {
9499 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9500 if (SWIG_arg_fail(2)) SWIG_fail;
9501 if (arg2 == NULL) {
9502 SWIG_null_ref("wxBitmap");
9503 }
9504 if (SWIG_arg_fail(2)) SWIG_fail;
9505 }
9506 {
9507 arg3 = (long)(SWIG_As_long(obj2));
9508 if (SWIG_arg_fail(3)) SWIG_fail;
9509 }
9510 {
9511 PyThreadState* __tstate = wxPyBeginAllowThreads();
9512 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9513
9514 wxPyEndAllowThreads(__tstate);
9515 if (PyErr_Occurred()) SWIG_fail;
9516 }
9517 Py_INCREF(Py_None); resultobj = Py_None;
9518 {
9519 if (temp1)
9520 delete arg1;
9521 }
9522 return resultobj;
9523 fail:
9524 {
9525 if (temp1)
9526 delete arg1;
9527 }
9528 return NULL;
9529 }
9530
9531
9532 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9533 PyObject *resultobj;
9534 wxString *arg1 = 0 ;
9535 PyObject *arg2 = (PyObject *) 0 ;
9536 bool temp1 = false ;
9537 PyObject * obj0 = 0 ;
9538 PyObject * obj1 = 0 ;
9539 char *kwnames[] = {
9540 (char *) "filename",(char *) "data", NULL
9541 };
9542
9543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9544 {
9545 arg1 = wxString_in_helper(obj0);
9546 if (arg1 == NULL) SWIG_fail;
9547 temp1 = true;
9548 }
9549 arg2 = obj1;
9550 {
9551 PyThreadState* __tstate = wxPyBeginAllowThreads();
9552 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9553
9554 wxPyEndAllowThreads(__tstate);
9555 if (PyErr_Occurred()) SWIG_fail;
9556 }
9557 Py_INCREF(Py_None); resultobj = Py_None;
9558 {
9559 if (temp1)
9560 delete arg1;
9561 }
9562 return resultobj;
9563 fail:
9564 {
9565 if (temp1)
9566 delete arg1;
9567 }
9568 return NULL;
9569 }
9570
9571
9572 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9573 PyObject *resultobj;
9574 wxMemoryFSHandler *result;
9575 char *kwnames[] = {
9576 NULL
9577 };
9578
9579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9580 {
9581 PyThreadState* __tstate = wxPyBeginAllowThreads();
9582 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9583
9584 wxPyEndAllowThreads(__tstate);
9585 if (PyErr_Occurred()) SWIG_fail;
9586 }
9587 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9588 return resultobj;
9589 fail:
9590 return NULL;
9591 }
9592
9593
9594 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9595 PyObject *resultobj;
9596 wxString *arg1 = 0 ;
9597 bool temp1 = false ;
9598 PyObject * obj0 = 0 ;
9599 char *kwnames[] = {
9600 (char *) "filename", NULL
9601 };
9602
9603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9604 {
9605 arg1 = wxString_in_helper(obj0);
9606 if (arg1 == NULL) SWIG_fail;
9607 temp1 = true;
9608 }
9609 {
9610 PyThreadState* __tstate = wxPyBeginAllowThreads();
9611 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9612
9613 wxPyEndAllowThreads(__tstate);
9614 if (PyErr_Occurred()) SWIG_fail;
9615 }
9616 Py_INCREF(Py_None); resultobj = Py_None;
9617 {
9618 if (temp1)
9619 delete arg1;
9620 }
9621 return resultobj;
9622 fail:
9623 {
9624 if (temp1)
9625 delete arg1;
9626 }
9627 return NULL;
9628 }
9629
9630
9631 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9632 PyObject *resultobj;
9633 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9634 wxString *arg2 = 0 ;
9635 bool result;
9636 bool temp2 = false ;
9637 PyObject * obj0 = 0 ;
9638 PyObject * obj1 = 0 ;
9639 char *kwnames[] = {
9640 (char *) "self",(char *) "location", NULL
9641 };
9642
9643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9645 if (SWIG_arg_fail(1)) SWIG_fail;
9646 {
9647 arg2 = wxString_in_helper(obj1);
9648 if (arg2 == NULL) SWIG_fail;
9649 temp2 = true;
9650 }
9651 {
9652 PyThreadState* __tstate = wxPyBeginAllowThreads();
9653 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9654
9655 wxPyEndAllowThreads(__tstate);
9656 if (PyErr_Occurred()) SWIG_fail;
9657 }
9658 {
9659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9660 }
9661 {
9662 if (temp2)
9663 delete arg2;
9664 }
9665 return resultobj;
9666 fail:
9667 {
9668 if (temp2)
9669 delete arg2;
9670 }
9671 return NULL;
9672 }
9673
9674
9675 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9676 PyObject *resultobj;
9677 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9678 wxFileSystem *arg2 = 0 ;
9679 wxString *arg3 = 0 ;
9680 wxFSFile *result;
9681 bool temp3 = false ;
9682 PyObject * obj0 = 0 ;
9683 PyObject * obj1 = 0 ;
9684 PyObject * obj2 = 0 ;
9685 char *kwnames[] = {
9686 (char *) "self",(char *) "fs",(char *) "location", NULL
9687 };
9688
9689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9691 if (SWIG_arg_fail(1)) SWIG_fail;
9692 {
9693 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9694 if (SWIG_arg_fail(2)) SWIG_fail;
9695 if (arg2 == NULL) {
9696 SWIG_null_ref("wxFileSystem");
9697 }
9698 if (SWIG_arg_fail(2)) SWIG_fail;
9699 }
9700 {
9701 arg3 = wxString_in_helper(obj2);
9702 if (arg3 == NULL) SWIG_fail;
9703 temp3 = true;
9704 }
9705 {
9706 PyThreadState* __tstate = wxPyBeginAllowThreads();
9707 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9708
9709 wxPyEndAllowThreads(__tstate);
9710 if (PyErr_Occurred()) SWIG_fail;
9711 }
9712 {
9713 resultobj = wxPyMake_wxObject(result, 1);
9714 }
9715 {
9716 if (temp3)
9717 delete arg3;
9718 }
9719 return resultobj;
9720 fail:
9721 {
9722 if (temp3)
9723 delete arg3;
9724 }
9725 return NULL;
9726 }
9727
9728
9729 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9730 PyObject *resultobj;
9731 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9732 wxString *arg2 = 0 ;
9733 int arg3 = (int) 0 ;
9734 wxString result;
9735 bool temp2 = false ;
9736 PyObject * obj0 = 0 ;
9737 PyObject * obj1 = 0 ;
9738 PyObject * obj2 = 0 ;
9739 char *kwnames[] = {
9740 (char *) "self",(char *) "spec",(char *) "flags", NULL
9741 };
9742
9743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9745 if (SWIG_arg_fail(1)) SWIG_fail;
9746 {
9747 arg2 = wxString_in_helper(obj1);
9748 if (arg2 == NULL) SWIG_fail;
9749 temp2 = true;
9750 }
9751 if (obj2) {
9752 {
9753 arg3 = (int)(SWIG_As_int(obj2));
9754 if (SWIG_arg_fail(3)) SWIG_fail;
9755 }
9756 }
9757 {
9758 PyThreadState* __tstate = wxPyBeginAllowThreads();
9759 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9760
9761 wxPyEndAllowThreads(__tstate);
9762 if (PyErr_Occurred()) SWIG_fail;
9763 }
9764 {
9765 #if wxUSE_UNICODE
9766 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9767 #else
9768 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9769 #endif
9770 }
9771 {
9772 if (temp2)
9773 delete arg2;
9774 }
9775 return resultobj;
9776 fail:
9777 {
9778 if (temp2)
9779 delete arg2;
9780 }
9781 return NULL;
9782 }
9783
9784
9785 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9786 PyObject *resultobj;
9787 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9788 wxString result;
9789 PyObject * obj0 = 0 ;
9790 char *kwnames[] = {
9791 (char *) "self", NULL
9792 };
9793
9794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9796 if (SWIG_arg_fail(1)) SWIG_fail;
9797 {
9798 PyThreadState* __tstate = wxPyBeginAllowThreads();
9799 result = (arg1)->FindNext();
9800
9801 wxPyEndAllowThreads(__tstate);
9802 if (PyErr_Occurred()) SWIG_fail;
9803 }
9804 {
9805 #if wxUSE_UNICODE
9806 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9807 #else
9808 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9809 #endif
9810 }
9811 return resultobj;
9812 fail:
9813 return NULL;
9814 }
9815
9816
9817 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9818 PyObject *obj;
9819 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9820 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9821 Py_INCREF(obj);
9822 return Py_BuildValue((char *)"");
9823 }
9824 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9825 PyObject *resultobj;
9826 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9827 wxString result;
9828 PyObject * obj0 = 0 ;
9829 char *kwnames[] = {
9830 (char *) "self", NULL
9831 };
9832
9833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9835 if (SWIG_arg_fail(1)) SWIG_fail;
9836 {
9837 PyThreadState* __tstate = wxPyBeginAllowThreads();
9838 result = (arg1)->GetName();
9839
9840 wxPyEndAllowThreads(__tstate);
9841 if (PyErr_Occurred()) SWIG_fail;
9842 }
9843 {
9844 #if wxUSE_UNICODE
9845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9846 #else
9847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9848 #endif
9849 }
9850 return resultobj;
9851 fail:
9852 return NULL;
9853 }
9854
9855
9856 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9857 PyObject *resultobj;
9858 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9859 wxString result;
9860 PyObject * obj0 = 0 ;
9861 char *kwnames[] = {
9862 (char *) "self", NULL
9863 };
9864
9865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9867 if (SWIG_arg_fail(1)) SWIG_fail;
9868 {
9869 PyThreadState* __tstate = wxPyBeginAllowThreads();
9870 result = (arg1)->GetExtension();
9871
9872 wxPyEndAllowThreads(__tstate);
9873 if (PyErr_Occurred()) SWIG_fail;
9874 }
9875 {
9876 #if wxUSE_UNICODE
9877 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9878 #else
9879 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9880 #endif
9881 }
9882 return resultobj;
9883 fail:
9884 return NULL;
9885 }
9886
9887
9888 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9889 PyObject *resultobj;
9890 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9891 long result;
9892 PyObject * obj0 = 0 ;
9893 char *kwnames[] = {
9894 (char *) "self", NULL
9895 };
9896
9897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9899 if (SWIG_arg_fail(1)) SWIG_fail;
9900 {
9901 PyThreadState* __tstate = wxPyBeginAllowThreads();
9902 result = (long)(arg1)->GetType();
9903
9904 wxPyEndAllowThreads(__tstate);
9905 if (PyErr_Occurred()) SWIG_fail;
9906 }
9907 {
9908 resultobj = SWIG_From_long((long)(result));
9909 }
9910 return resultobj;
9911 fail:
9912 return NULL;
9913 }
9914
9915
9916 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9917 PyObject *resultobj;
9918 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9919 wxString result;
9920 PyObject * obj0 = 0 ;
9921 char *kwnames[] = {
9922 (char *) "self", NULL
9923 };
9924
9925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9927 if (SWIG_arg_fail(1)) SWIG_fail;
9928 {
9929 PyThreadState* __tstate = wxPyBeginAllowThreads();
9930 result = (arg1)->GetMimeType();
9931
9932 wxPyEndAllowThreads(__tstate);
9933 if (PyErr_Occurred()) SWIG_fail;
9934 }
9935 {
9936 #if wxUSE_UNICODE
9937 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9938 #else
9939 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9940 #endif
9941 }
9942 return resultobj;
9943 fail:
9944 return NULL;
9945 }
9946
9947
9948 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9949 PyObject *resultobj;
9950 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9951 wxString *arg2 = 0 ;
9952 bool result;
9953 bool temp2 = false ;
9954 PyObject * obj0 = 0 ;
9955 PyObject * obj1 = 0 ;
9956 char *kwnames[] = {
9957 (char *) "self",(char *) "name", NULL
9958 };
9959
9960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
9961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9962 if (SWIG_arg_fail(1)) SWIG_fail;
9963 {
9964 arg2 = wxString_in_helper(obj1);
9965 if (arg2 == NULL) SWIG_fail;
9966 temp2 = true;
9967 }
9968 {
9969 PyThreadState* __tstate = wxPyBeginAllowThreads();
9970 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
9971
9972 wxPyEndAllowThreads(__tstate);
9973 if (PyErr_Occurred()) SWIG_fail;
9974 }
9975 {
9976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9977 }
9978 {
9979 if (temp2)
9980 delete arg2;
9981 }
9982 return resultobj;
9983 fail:
9984 {
9985 if (temp2)
9986 delete arg2;
9987 }
9988 return NULL;
9989 }
9990
9991
9992 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
9993 PyObject *resultobj;
9994 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9995 wxString *arg2 = 0 ;
9996 bool temp2 = false ;
9997 PyObject * obj0 = 0 ;
9998 PyObject * obj1 = 0 ;
9999 char *kwnames[] = {
10000 (char *) "self",(char *) "name", NULL
10001 };
10002
10003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10005 if (SWIG_arg_fail(1)) SWIG_fail;
10006 {
10007 arg2 = wxString_in_helper(obj1);
10008 if (arg2 == NULL) SWIG_fail;
10009 temp2 = true;
10010 }
10011 {
10012 PyThreadState* __tstate = wxPyBeginAllowThreads();
10013 (arg1)->SetName((wxString const &)*arg2);
10014
10015 wxPyEndAllowThreads(__tstate);
10016 if (PyErr_Occurred()) SWIG_fail;
10017 }
10018 Py_INCREF(Py_None); resultobj = Py_None;
10019 {
10020 if (temp2)
10021 delete arg2;
10022 }
10023 return resultobj;
10024 fail:
10025 {
10026 if (temp2)
10027 delete arg2;
10028 }
10029 return NULL;
10030 }
10031
10032
10033 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10034 PyObject *resultobj;
10035 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10036 wxString *arg2 = 0 ;
10037 bool temp2 = false ;
10038 PyObject * obj0 = 0 ;
10039 PyObject * obj1 = 0 ;
10040 char *kwnames[] = {
10041 (char *) "self",(char *) "extension", NULL
10042 };
10043
10044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10046 if (SWIG_arg_fail(1)) SWIG_fail;
10047 {
10048 arg2 = wxString_in_helper(obj1);
10049 if (arg2 == NULL) SWIG_fail;
10050 temp2 = true;
10051 }
10052 {
10053 PyThreadState* __tstate = wxPyBeginAllowThreads();
10054 (arg1)->SetExtension((wxString const &)*arg2);
10055
10056 wxPyEndAllowThreads(__tstate);
10057 if (PyErr_Occurred()) SWIG_fail;
10058 }
10059 Py_INCREF(Py_None); resultobj = Py_None;
10060 {
10061 if (temp2)
10062 delete arg2;
10063 }
10064 return resultobj;
10065 fail:
10066 {
10067 if (temp2)
10068 delete arg2;
10069 }
10070 return NULL;
10071 }
10072
10073
10074 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10075 PyObject *resultobj;
10076 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10077 long arg2 ;
10078 PyObject * obj0 = 0 ;
10079 PyObject * obj1 = 0 ;
10080 char *kwnames[] = {
10081 (char *) "self",(char *) "type", NULL
10082 };
10083
10084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10086 if (SWIG_arg_fail(1)) SWIG_fail;
10087 {
10088 arg2 = (long)(SWIG_As_long(obj1));
10089 if (SWIG_arg_fail(2)) SWIG_fail;
10090 }
10091 {
10092 PyThreadState* __tstate = wxPyBeginAllowThreads();
10093 (arg1)->SetType(arg2);
10094
10095 wxPyEndAllowThreads(__tstate);
10096 if (PyErr_Occurred()) SWIG_fail;
10097 }
10098 Py_INCREF(Py_None); resultobj = Py_None;
10099 return resultobj;
10100 fail:
10101 return NULL;
10102 }
10103
10104
10105 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10106 PyObject *resultobj;
10107 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10108 wxString *arg2 = 0 ;
10109 bool temp2 = false ;
10110 PyObject * obj0 = 0 ;
10111 PyObject * obj1 = 0 ;
10112 char *kwnames[] = {
10113 (char *) "self",(char *) "mimetype", NULL
10114 };
10115
10116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10118 if (SWIG_arg_fail(1)) SWIG_fail;
10119 {
10120 arg2 = wxString_in_helper(obj1);
10121 if (arg2 == NULL) SWIG_fail;
10122 temp2 = true;
10123 }
10124 {
10125 PyThreadState* __tstate = wxPyBeginAllowThreads();
10126 (arg1)->SetMimeType((wxString const &)*arg2);
10127
10128 wxPyEndAllowThreads(__tstate);
10129 if (PyErr_Occurred()) SWIG_fail;
10130 }
10131 Py_INCREF(Py_None); resultobj = Py_None;
10132 {
10133 if (temp2)
10134 delete arg2;
10135 }
10136 return resultobj;
10137 fail:
10138 {
10139 if (temp2)
10140 delete arg2;
10141 }
10142 return NULL;
10143 }
10144
10145
10146 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10147 PyObject *obj;
10148 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10149 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10150 Py_INCREF(obj);
10151 return Py_BuildValue((char *)"");
10152 }
10153 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10154 PyObject *resultobj;
10155 wxImageHistogram *result;
10156 char *kwnames[] = {
10157 NULL
10158 };
10159
10160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10161 {
10162 PyThreadState* __tstate = wxPyBeginAllowThreads();
10163 result = (wxImageHistogram *)new wxImageHistogram();
10164
10165 wxPyEndAllowThreads(__tstate);
10166 if (PyErr_Occurred()) SWIG_fail;
10167 }
10168 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10169 return resultobj;
10170 fail:
10171 return NULL;
10172 }
10173
10174
10175 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10176 PyObject *resultobj;
10177 unsigned char arg1 ;
10178 unsigned char arg2 ;
10179 unsigned char arg3 ;
10180 unsigned long result;
10181 PyObject * obj0 = 0 ;
10182 PyObject * obj1 = 0 ;
10183 PyObject * obj2 = 0 ;
10184 char *kwnames[] = {
10185 (char *) "r",(char *) "g",(char *) "b", NULL
10186 };
10187
10188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10189 {
10190 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10191 if (SWIG_arg_fail(1)) SWIG_fail;
10192 }
10193 {
10194 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10195 if (SWIG_arg_fail(2)) SWIG_fail;
10196 }
10197 {
10198 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10199 if (SWIG_arg_fail(3)) SWIG_fail;
10200 }
10201 {
10202 PyThreadState* __tstate = wxPyBeginAllowThreads();
10203 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10204
10205 wxPyEndAllowThreads(__tstate);
10206 if (PyErr_Occurred()) SWIG_fail;
10207 }
10208 {
10209 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10210 }
10211 return resultobj;
10212 fail:
10213 return NULL;
10214 }
10215
10216
10217 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10218 PyObject *resultobj;
10219 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10220 unsigned char *arg2 = (unsigned char *) 0 ;
10221 unsigned char *arg3 = (unsigned char *) 0 ;
10222 unsigned char *arg4 = (unsigned char *) 0 ;
10223 unsigned char arg5 = (unsigned char) 1 ;
10224 unsigned char arg6 = (unsigned char) 0 ;
10225 unsigned char arg7 = (unsigned char) 0 ;
10226 bool result;
10227 unsigned char temp2 ;
10228 int res2 = 0 ;
10229 unsigned char temp3 ;
10230 int res3 = 0 ;
10231 unsigned char temp4 ;
10232 int res4 = 0 ;
10233 PyObject * obj0 = 0 ;
10234 PyObject * obj1 = 0 ;
10235 PyObject * obj2 = 0 ;
10236 PyObject * obj3 = 0 ;
10237 char *kwnames[] = {
10238 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10239 };
10240
10241 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10242 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10243 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10246 if (SWIG_arg_fail(1)) SWIG_fail;
10247 if (obj1) {
10248 {
10249 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10250 if (SWIG_arg_fail(5)) SWIG_fail;
10251 }
10252 }
10253 if (obj2) {
10254 {
10255 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10256 if (SWIG_arg_fail(6)) SWIG_fail;
10257 }
10258 }
10259 if (obj3) {
10260 {
10261 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10262 if (SWIG_arg_fail(7)) SWIG_fail;
10263 }
10264 }
10265 {
10266 PyThreadState* __tstate = wxPyBeginAllowThreads();
10267 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10268
10269 wxPyEndAllowThreads(__tstate);
10270 if (PyErr_Occurred()) SWIG_fail;
10271 }
10272 {
10273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10274 }
10275 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10276 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10277 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10278 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10279 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10280 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10281 return resultobj;
10282 fail:
10283 return NULL;
10284 }
10285
10286
10287 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10288 PyObject *obj;
10289 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10290 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10291 Py_INCREF(obj);
10292 return Py_BuildValue((char *)"");
10293 }
10294 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10295 PyObject *resultobj;
10296 wxString *arg1 = 0 ;
10297 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10298 int arg3 = (int) -1 ;
10299 wxImage *result;
10300 bool temp1 = false ;
10301 PyObject * obj0 = 0 ;
10302 PyObject * obj1 = 0 ;
10303 PyObject * obj2 = 0 ;
10304 char *kwnames[] = {
10305 (char *) "name",(char *) "type",(char *) "index", NULL
10306 };
10307
10308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10309 {
10310 arg1 = wxString_in_helper(obj0);
10311 if (arg1 == NULL) SWIG_fail;
10312 temp1 = true;
10313 }
10314 if (obj1) {
10315 {
10316 arg2 = (long)(SWIG_As_long(obj1));
10317 if (SWIG_arg_fail(2)) SWIG_fail;
10318 }
10319 }
10320 if (obj2) {
10321 {
10322 arg3 = (int)(SWIG_As_int(obj2));
10323 if (SWIG_arg_fail(3)) SWIG_fail;
10324 }
10325 }
10326 {
10327 PyThreadState* __tstate = wxPyBeginAllowThreads();
10328 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10329
10330 wxPyEndAllowThreads(__tstate);
10331 if (PyErr_Occurred()) SWIG_fail;
10332 }
10333 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10334 {
10335 if (temp1)
10336 delete arg1;
10337 }
10338 return resultobj;
10339 fail:
10340 {
10341 if (temp1)
10342 delete arg1;
10343 }
10344 return NULL;
10345 }
10346
10347
10348 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10349 PyObject *resultobj;
10350 wxImage *arg1 = (wxImage *) 0 ;
10351 PyObject * obj0 = 0 ;
10352 char *kwnames[] = {
10353 (char *) "self", NULL
10354 };
10355
10356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10358 if (SWIG_arg_fail(1)) SWIG_fail;
10359 {
10360 PyThreadState* __tstate = wxPyBeginAllowThreads();
10361 delete arg1;
10362
10363 wxPyEndAllowThreads(__tstate);
10364 if (PyErr_Occurred()) SWIG_fail;
10365 }
10366 Py_INCREF(Py_None); resultobj = Py_None;
10367 return resultobj;
10368 fail:
10369 return NULL;
10370 }
10371
10372
10373 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10374 PyObject *resultobj;
10375 wxString *arg1 = 0 ;
10376 wxString *arg2 = 0 ;
10377 int arg3 = (int) -1 ;
10378 wxImage *result;
10379 bool temp1 = false ;
10380 bool temp2 = false ;
10381 PyObject * obj0 = 0 ;
10382 PyObject * obj1 = 0 ;
10383 PyObject * obj2 = 0 ;
10384 char *kwnames[] = {
10385 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10386 };
10387
10388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10389 {
10390 arg1 = wxString_in_helper(obj0);
10391 if (arg1 == NULL) SWIG_fail;
10392 temp1 = true;
10393 }
10394 {
10395 arg2 = wxString_in_helper(obj1);
10396 if (arg2 == NULL) SWIG_fail;
10397 temp2 = true;
10398 }
10399 if (obj2) {
10400 {
10401 arg3 = (int)(SWIG_As_int(obj2));
10402 if (SWIG_arg_fail(3)) SWIG_fail;
10403 }
10404 }
10405 {
10406 PyThreadState* __tstate = wxPyBeginAllowThreads();
10407 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10408
10409 wxPyEndAllowThreads(__tstate);
10410 if (PyErr_Occurred()) SWIG_fail;
10411 }
10412 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10413 {
10414 if (temp1)
10415 delete arg1;
10416 }
10417 {
10418 if (temp2)
10419 delete arg2;
10420 }
10421 return resultobj;
10422 fail:
10423 {
10424 if (temp1)
10425 delete arg1;
10426 }
10427 {
10428 if (temp2)
10429 delete arg2;
10430 }
10431 return NULL;
10432 }
10433
10434
10435 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10436 PyObject *resultobj;
10437 wxInputStream *arg1 = 0 ;
10438 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10439 int arg3 = (int) -1 ;
10440 wxImage *result;
10441 wxPyInputStream *temp1 ;
10442 bool created1 ;
10443 PyObject * obj0 = 0 ;
10444 PyObject * obj1 = 0 ;
10445 PyObject * obj2 = 0 ;
10446 char *kwnames[] = {
10447 (char *) "stream",(char *) "type",(char *) "index", NULL
10448 };
10449
10450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10451 {
10452 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10453 arg1 = temp1->m_wxis;
10454 created1 = false;
10455 } else {
10456 PyErr_Clear(); // clear the failure of the wxPyConvert above
10457 arg1 = wxPyCBInputStream_create(obj0, false);
10458 if (arg1 == NULL) {
10459 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10460 SWIG_fail;
10461 }
10462 created1 = true;
10463 }
10464 }
10465 if (obj1) {
10466 {
10467 arg2 = (long)(SWIG_As_long(obj1));
10468 if (SWIG_arg_fail(2)) SWIG_fail;
10469 }
10470 }
10471 if (obj2) {
10472 {
10473 arg3 = (int)(SWIG_As_int(obj2));
10474 if (SWIG_arg_fail(3)) SWIG_fail;
10475 }
10476 }
10477 {
10478 PyThreadState* __tstate = wxPyBeginAllowThreads();
10479 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10480
10481 wxPyEndAllowThreads(__tstate);
10482 if (PyErr_Occurred()) SWIG_fail;
10483 }
10484 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10485 {
10486 if (created1)
10487 delete arg1;
10488 }
10489 return resultobj;
10490 fail:
10491 {
10492 if (created1)
10493 delete arg1;
10494 }
10495 return NULL;
10496 }
10497
10498
10499 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10500 PyObject *resultobj;
10501 wxInputStream *arg1 = 0 ;
10502 wxString *arg2 = 0 ;
10503 int arg3 = (int) -1 ;
10504 wxImage *result;
10505 wxPyInputStream *temp1 ;
10506 bool created1 ;
10507 bool temp2 = false ;
10508 PyObject * obj0 = 0 ;
10509 PyObject * obj1 = 0 ;
10510 PyObject * obj2 = 0 ;
10511 char *kwnames[] = {
10512 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10513 };
10514
10515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10516 {
10517 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10518 arg1 = temp1->m_wxis;
10519 created1 = false;
10520 } else {
10521 PyErr_Clear(); // clear the failure of the wxPyConvert above
10522 arg1 = wxPyCBInputStream_create(obj0, false);
10523 if (arg1 == NULL) {
10524 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10525 SWIG_fail;
10526 }
10527 created1 = true;
10528 }
10529 }
10530 {
10531 arg2 = wxString_in_helper(obj1);
10532 if (arg2 == NULL) SWIG_fail;
10533 temp2 = true;
10534 }
10535 if (obj2) {
10536 {
10537 arg3 = (int)(SWIG_As_int(obj2));
10538 if (SWIG_arg_fail(3)) SWIG_fail;
10539 }
10540 }
10541 {
10542 PyThreadState* __tstate = wxPyBeginAllowThreads();
10543 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10544
10545 wxPyEndAllowThreads(__tstate);
10546 if (PyErr_Occurred()) SWIG_fail;
10547 }
10548 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10549 {
10550 if (created1)
10551 delete arg1;
10552 }
10553 {
10554 if (temp2)
10555 delete arg2;
10556 }
10557 return resultobj;
10558 fail:
10559 {
10560 if (created1)
10561 delete arg1;
10562 }
10563 {
10564 if (temp2)
10565 delete arg2;
10566 }
10567 return NULL;
10568 }
10569
10570
10571 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10572 PyObject *resultobj;
10573 int arg1 = (int) 0 ;
10574 int arg2 = (int) 0 ;
10575 bool arg3 = (bool) true ;
10576 wxImage *result;
10577 PyObject * obj0 = 0 ;
10578 PyObject * obj1 = 0 ;
10579 PyObject * obj2 = 0 ;
10580 char *kwnames[] = {
10581 (char *) "width",(char *) "height",(char *) "clear", NULL
10582 };
10583
10584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10585 if (obj0) {
10586 {
10587 arg1 = (int)(SWIG_As_int(obj0));
10588 if (SWIG_arg_fail(1)) SWIG_fail;
10589 }
10590 }
10591 if (obj1) {
10592 {
10593 arg2 = (int)(SWIG_As_int(obj1));
10594 if (SWIG_arg_fail(2)) SWIG_fail;
10595 }
10596 }
10597 if (obj2) {
10598 {
10599 arg3 = (bool)(SWIG_As_bool(obj2));
10600 if (SWIG_arg_fail(3)) SWIG_fail;
10601 }
10602 }
10603 {
10604 PyThreadState* __tstate = wxPyBeginAllowThreads();
10605 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10606
10607 wxPyEndAllowThreads(__tstate);
10608 if (PyErr_Occurred()) SWIG_fail;
10609 }
10610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10611 return resultobj;
10612 fail:
10613 return NULL;
10614 }
10615
10616
10617 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10618 PyObject *resultobj;
10619 wxBitmap *arg1 = 0 ;
10620 wxImage *result;
10621 PyObject * obj0 = 0 ;
10622 char *kwnames[] = {
10623 (char *) "bitmap", NULL
10624 };
10625
10626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10627 {
10628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10629 if (SWIG_arg_fail(1)) SWIG_fail;
10630 if (arg1 == NULL) {
10631 SWIG_null_ref("wxBitmap");
10632 }
10633 if (SWIG_arg_fail(1)) SWIG_fail;
10634 }
10635 {
10636 if (!wxPyCheckForApp()) SWIG_fail;
10637 PyThreadState* __tstate = wxPyBeginAllowThreads();
10638 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10639
10640 wxPyEndAllowThreads(__tstate);
10641 if (PyErr_Occurred()) SWIG_fail;
10642 }
10643 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10644 return resultobj;
10645 fail:
10646 return NULL;
10647 }
10648
10649
10650 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10651 PyObject *resultobj;
10652 int arg1 ;
10653 int arg2 ;
10654 unsigned char *arg3 = (unsigned char *) 0 ;
10655 wxImage *result;
10656 PyObject * obj0 = 0 ;
10657 PyObject * obj1 = 0 ;
10658 PyObject * obj2 = 0 ;
10659 char *kwnames[] = {
10660 (char *) "width",(char *) "height",(char *) "data", NULL
10661 };
10662
10663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10664 {
10665 arg1 = (int)(SWIG_As_int(obj0));
10666 if (SWIG_arg_fail(1)) SWIG_fail;
10667 }
10668 {
10669 arg2 = (int)(SWIG_As_int(obj1));
10670 if (SWIG_arg_fail(2)) SWIG_fail;
10671 }
10672 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10673 if (SWIG_arg_fail(3)) SWIG_fail;
10674 {
10675 PyThreadState* __tstate = wxPyBeginAllowThreads();
10676 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10677
10678 wxPyEndAllowThreads(__tstate);
10679 if (PyErr_Occurred()) SWIG_fail;
10680 }
10681 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10682 return resultobj;
10683 fail:
10684 return NULL;
10685 }
10686
10687
10688 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10689 PyObject *resultobj;
10690 int arg1 ;
10691 int arg2 ;
10692 unsigned char *arg3 = (unsigned char *) 0 ;
10693 unsigned char *arg4 = (unsigned char *) 0 ;
10694 wxImage *result;
10695 PyObject * obj0 = 0 ;
10696 PyObject * obj1 = 0 ;
10697 PyObject * obj2 = 0 ;
10698 PyObject * obj3 = 0 ;
10699 char *kwnames[] = {
10700 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10701 };
10702
10703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10704 {
10705 arg1 = (int)(SWIG_As_int(obj0));
10706 if (SWIG_arg_fail(1)) SWIG_fail;
10707 }
10708 {
10709 arg2 = (int)(SWIG_As_int(obj1));
10710 if (SWIG_arg_fail(2)) SWIG_fail;
10711 }
10712 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10713 if (SWIG_arg_fail(3)) SWIG_fail;
10714 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10715 if (SWIG_arg_fail(4)) SWIG_fail;
10716 {
10717 PyThreadState* __tstate = wxPyBeginAllowThreads();
10718 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10719
10720 wxPyEndAllowThreads(__tstate);
10721 if (PyErr_Occurred()) SWIG_fail;
10722 }
10723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10724 return resultobj;
10725 fail:
10726 return NULL;
10727 }
10728
10729
10730 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10731 PyObject *resultobj;
10732 wxImage *arg1 = (wxImage *) 0 ;
10733 int arg2 ;
10734 int arg3 ;
10735 PyObject * obj0 = 0 ;
10736 PyObject * obj1 = 0 ;
10737 PyObject * obj2 = 0 ;
10738 char *kwnames[] = {
10739 (char *) "self",(char *) "width",(char *) "height", NULL
10740 };
10741
10742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10744 if (SWIG_arg_fail(1)) SWIG_fail;
10745 {
10746 arg2 = (int)(SWIG_As_int(obj1));
10747 if (SWIG_arg_fail(2)) SWIG_fail;
10748 }
10749 {
10750 arg3 = (int)(SWIG_As_int(obj2));
10751 if (SWIG_arg_fail(3)) SWIG_fail;
10752 }
10753 {
10754 PyThreadState* __tstate = wxPyBeginAllowThreads();
10755 (arg1)->Create(arg2,arg3);
10756
10757 wxPyEndAllowThreads(__tstate);
10758 if (PyErr_Occurred()) SWIG_fail;
10759 }
10760 Py_INCREF(Py_None); resultobj = Py_None;
10761 return resultobj;
10762 fail:
10763 return NULL;
10764 }
10765
10766
10767 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10768 PyObject *resultobj;
10769 wxImage *arg1 = (wxImage *) 0 ;
10770 PyObject * obj0 = 0 ;
10771 char *kwnames[] = {
10772 (char *) "self", NULL
10773 };
10774
10775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10777 if (SWIG_arg_fail(1)) SWIG_fail;
10778 {
10779 PyThreadState* __tstate = wxPyBeginAllowThreads();
10780 (arg1)->Destroy();
10781
10782 wxPyEndAllowThreads(__tstate);
10783 if (PyErr_Occurred()) SWIG_fail;
10784 }
10785 Py_INCREF(Py_None); resultobj = Py_None;
10786 return resultobj;
10787 fail:
10788 return NULL;
10789 }
10790
10791
10792 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10793 PyObject *resultobj;
10794 wxImage *arg1 = (wxImage *) 0 ;
10795 int arg2 ;
10796 int arg3 ;
10797 SwigValueWrapper<wxImage > result;
10798 PyObject * obj0 = 0 ;
10799 PyObject * obj1 = 0 ;
10800 PyObject * obj2 = 0 ;
10801 char *kwnames[] = {
10802 (char *) "self",(char *) "width",(char *) "height", NULL
10803 };
10804
10805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10807 if (SWIG_arg_fail(1)) SWIG_fail;
10808 {
10809 arg2 = (int)(SWIG_As_int(obj1));
10810 if (SWIG_arg_fail(2)) SWIG_fail;
10811 }
10812 {
10813 arg3 = (int)(SWIG_As_int(obj2));
10814 if (SWIG_arg_fail(3)) SWIG_fail;
10815 }
10816 {
10817 PyThreadState* __tstate = wxPyBeginAllowThreads();
10818 result = (arg1)->Scale(arg2,arg3);
10819
10820 wxPyEndAllowThreads(__tstate);
10821 if (PyErr_Occurred()) SWIG_fail;
10822 }
10823 {
10824 wxImage * resultptr;
10825 resultptr = new wxImage((wxImage &)(result));
10826 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10827 }
10828 return resultobj;
10829 fail:
10830 return NULL;
10831 }
10832
10833
10834 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10835 PyObject *resultobj;
10836 wxImage *arg1 = (wxImage *) 0 ;
10837 int arg2 ;
10838 int arg3 ;
10839 SwigValueWrapper<wxImage > result;
10840 PyObject * obj0 = 0 ;
10841 PyObject * obj1 = 0 ;
10842 PyObject * obj2 = 0 ;
10843 char *kwnames[] = {
10844 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10845 };
10846
10847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10849 if (SWIG_arg_fail(1)) SWIG_fail;
10850 {
10851 arg2 = (int)(SWIG_As_int(obj1));
10852 if (SWIG_arg_fail(2)) SWIG_fail;
10853 }
10854 {
10855 arg3 = (int)(SWIG_As_int(obj2));
10856 if (SWIG_arg_fail(3)) SWIG_fail;
10857 }
10858 {
10859 PyThreadState* __tstate = wxPyBeginAllowThreads();
10860 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10861
10862 wxPyEndAllowThreads(__tstate);
10863 if (PyErr_Occurred()) SWIG_fail;
10864 }
10865 {
10866 wxImage * resultptr;
10867 resultptr = new wxImage((wxImage &)(result));
10868 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10869 }
10870 return resultobj;
10871 fail:
10872 return NULL;
10873 }
10874
10875
10876 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10877 PyObject *resultobj;
10878 wxImage *arg1 = (wxImage *) 0 ;
10879 int arg2 ;
10880 int arg3 ;
10881 wxImage *result;
10882 PyObject * obj0 = 0 ;
10883 PyObject * obj1 = 0 ;
10884 PyObject * obj2 = 0 ;
10885 char *kwnames[] = {
10886 (char *) "self",(char *) "width",(char *) "height", NULL
10887 };
10888
10889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10891 if (SWIG_arg_fail(1)) SWIG_fail;
10892 {
10893 arg2 = (int)(SWIG_As_int(obj1));
10894 if (SWIG_arg_fail(2)) SWIG_fail;
10895 }
10896 {
10897 arg3 = (int)(SWIG_As_int(obj2));
10898 if (SWIG_arg_fail(3)) SWIG_fail;
10899 }
10900 {
10901 PyThreadState* __tstate = wxPyBeginAllowThreads();
10902 {
10903 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10904 result = (wxImage *) &_result_ref;
10905 }
10906
10907 wxPyEndAllowThreads(__tstate);
10908 if (PyErr_Occurred()) SWIG_fail;
10909 }
10910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10911 return resultobj;
10912 fail:
10913 return NULL;
10914 }
10915
10916
10917 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10918 PyObject *resultobj;
10919 wxImage *arg1 = (wxImage *) 0 ;
10920 int arg2 ;
10921 int arg3 ;
10922 unsigned char arg4 ;
10923 unsigned char arg5 ;
10924 unsigned char arg6 ;
10925 PyObject * obj0 = 0 ;
10926 PyObject * obj1 = 0 ;
10927 PyObject * obj2 = 0 ;
10928 PyObject * obj3 = 0 ;
10929 PyObject * obj4 = 0 ;
10930 PyObject * obj5 = 0 ;
10931 char *kwnames[] = {
10932 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
10933 };
10934
10935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10937 if (SWIG_arg_fail(1)) SWIG_fail;
10938 {
10939 arg2 = (int)(SWIG_As_int(obj1));
10940 if (SWIG_arg_fail(2)) SWIG_fail;
10941 }
10942 {
10943 arg3 = (int)(SWIG_As_int(obj2));
10944 if (SWIG_arg_fail(3)) SWIG_fail;
10945 }
10946 {
10947 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10948 if (SWIG_arg_fail(4)) SWIG_fail;
10949 }
10950 {
10951 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
10952 if (SWIG_arg_fail(5)) SWIG_fail;
10953 }
10954 {
10955 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
10956 if (SWIG_arg_fail(6)) SWIG_fail;
10957 }
10958 {
10959 PyThreadState* __tstate = wxPyBeginAllowThreads();
10960 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
10961
10962 wxPyEndAllowThreads(__tstate);
10963 if (PyErr_Occurred()) SWIG_fail;
10964 }
10965 Py_INCREF(Py_None); resultobj = Py_None;
10966 return resultobj;
10967 fail:
10968 return NULL;
10969 }
10970
10971
10972 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
10973 PyObject *resultobj;
10974 wxImage *arg1 = (wxImage *) 0 ;
10975 int arg2 ;
10976 int arg3 ;
10977 unsigned char result;
10978 PyObject * obj0 = 0 ;
10979 PyObject * obj1 = 0 ;
10980 PyObject * obj2 = 0 ;
10981 char *kwnames[] = {
10982 (char *) "self",(char *) "x",(char *) "y", NULL
10983 };
10984
10985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
10986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10987 if (SWIG_arg_fail(1)) SWIG_fail;
10988 {
10989 arg2 = (int)(SWIG_As_int(obj1));
10990 if (SWIG_arg_fail(2)) SWIG_fail;
10991 }
10992 {
10993 arg3 = (int)(SWIG_As_int(obj2));
10994 if (SWIG_arg_fail(3)) SWIG_fail;
10995 }
10996 {
10997 PyThreadState* __tstate = wxPyBeginAllowThreads();
10998 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
10999
11000 wxPyEndAllowThreads(__tstate);
11001 if (PyErr_Occurred()) SWIG_fail;
11002 }
11003 {
11004 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11005 }
11006 return resultobj;
11007 fail:
11008 return NULL;
11009 }
11010
11011
11012 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11013 PyObject *resultobj;
11014 wxImage *arg1 = (wxImage *) 0 ;
11015 int arg2 ;
11016 int arg3 ;
11017 unsigned char result;
11018 PyObject * obj0 = 0 ;
11019 PyObject * obj1 = 0 ;
11020 PyObject * obj2 = 0 ;
11021 char *kwnames[] = {
11022 (char *) "self",(char *) "x",(char *) "y", NULL
11023 };
11024
11025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11027 if (SWIG_arg_fail(1)) SWIG_fail;
11028 {
11029 arg2 = (int)(SWIG_As_int(obj1));
11030 if (SWIG_arg_fail(2)) SWIG_fail;
11031 }
11032 {
11033 arg3 = (int)(SWIG_As_int(obj2));
11034 if (SWIG_arg_fail(3)) SWIG_fail;
11035 }
11036 {
11037 PyThreadState* __tstate = wxPyBeginAllowThreads();
11038 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11039
11040 wxPyEndAllowThreads(__tstate);
11041 if (PyErr_Occurred()) SWIG_fail;
11042 }
11043 {
11044 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11045 }
11046 return resultobj;
11047 fail:
11048 return NULL;
11049 }
11050
11051
11052 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11053 PyObject *resultobj;
11054 wxImage *arg1 = (wxImage *) 0 ;
11055 int arg2 ;
11056 int arg3 ;
11057 unsigned char result;
11058 PyObject * obj0 = 0 ;
11059 PyObject * obj1 = 0 ;
11060 PyObject * obj2 = 0 ;
11061 char *kwnames[] = {
11062 (char *) "self",(char *) "x",(char *) "y", NULL
11063 };
11064
11065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11067 if (SWIG_arg_fail(1)) SWIG_fail;
11068 {
11069 arg2 = (int)(SWIG_As_int(obj1));
11070 if (SWIG_arg_fail(2)) SWIG_fail;
11071 }
11072 {
11073 arg3 = (int)(SWIG_As_int(obj2));
11074 if (SWIG_arg_fail(3)) SWIG_fail;
11075 }
11076 {
11077 PyThreadState* __tstate = wxPyBeginAllowThreads();
11078 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11079
11080 wxPyEndAllowThreads(__tstate);
11081 if (PyErr_Occurred()) SWIG_fail;
11082 }
11083 {
11084 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11085 }
11086 return resultobj;
11087 fail:
11088 return NULL;
11089 }
11090
11091
11092 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11093 PyObject *resultobj;
11094 wxImage *arg1 = (wxImage *) 0 ;
11095 int arg2 ;
11096 int arg3 ;
11097 unsigned char arg4 ;
11098 PyObject * obj0 = 0 ;
11099 PyObject * obj1 = 0 ;
11100 PyObject * obj2 = 0 ;
11101 PyObject * obj3 = 0 ;
11102 char *kwnames[] = {
11103 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11104 };
11105
11106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11108 if (SWIG_arg_fail(1)) SWIG_fail;
11109 {
11110 arg2 = (int)(SWIG_As_int(obj1));
11111 if (SWIG_arg_fail(2)) SWIG_fail;
11112 }
11113 {
11114 arg3 = (int)(SWIG_As_int(obj2));
11115 if (SWIG_arg_fail(3)) SWIG_fail;
11116 }
11117 {
11118 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11119 if (SWIG_arg_fail(4)) SWIG_fail;
11120 }
11121 {
11122 PyThreadState* __tstate = wxPyBeginAllowThreads();
11123 (arg1)->SetAlpha(arg2,arg3,arg4);
11124
11125 wxPyEndAllowThreads(__tstate);
11126 if (PyErr_Occurred()) SWIG_fail;
11127 }
11128 Py_INCREF(Py_None); resultobj = Py_None;
11129 return resultobj;
11130 fail:
11131 return NULL;
11132 }
11133
11134
11135 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11136 PyObject *resultobj;
11137 wxImage *arg1 = (wxImage *) 0 ;
11138 int arg2 ;
11139 int arg3 ;
11140 unsigned char result;
11141 PyObject * obj0 = 0 ;
11142 PyObject * obj1 = 0 ;
11143 PyObject * obj2 = 0 ;
11144 char *kwnames[] = {
11145 (char *) "self",(char *) "x",(char *) "y", NULL
11146 };
11147
11148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11150 if (SWIG_arg_fail(1)) SWIG_fail;
11151 {
11152 arg2 = (int)(SWIG_As_int(obj1));
11153 if (SWIG_arg_fail(2)) SWIG_fail;
11154 }
11155 {
11156 arg3 = (int)(SWIG_As_int(obj2));
11157 if (SWIG_arg_fail(3)) SWIG_fail;
11158 }
11159 {
11160 PyThreadState* __tstate = wxPyBeginAllowThreads();
11161 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11162
11163 wxPyEndAllowThreads(__tstate);
11164 if (PyErr_Occurred()) SWIG_fail;
11165 }
11166 {
11167 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11168 }
11169 return resultobj;
11170 fail:
11171 return NULL;
11172 }
11173
11174
11175 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11176 PyObject *resultobj;
11177 wxImage *arg1 = (wxImage *) 0 ;
11178 bool result;
11179 PyObject * obj0 = 0 ;
11180 char *kwnames[] = {
11181 (char *) "self", NULL
11182 };
11183
11184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11186 if (SWIG_arg_fail(1)) SWIG_fail;
11187 {
11188 PyThreadState* __tstate = wxPyBeginAllowThreads();
11189 result = (bool)(arg1)->HasAlpha();
11190
11191 wxPyEndAllowThreads(__tstate);
11192 if (PyErr_Occurred()) SWIG_fail;
11193 }
11194 {
11195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11196 }
11197 return resultobj;
11198 fail:
11199 return NULL;
11200 }
11201
11202
11203 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11204 PyObject *resultobj;
11205 wxImage *arg1 = (wxImage *) 0 ;
11206 byte *arg2 = (byte *) 0 ;
11207 byte *arg3 = (byte *) 0 ;
11208 byte *arg4 = (byte *) 0 ;
11209 byte arg5 = (byte) 0 ;
11210 byte arg6 = (byte) 0 ;
11211 byte arg7 = (byte) 0 ;
11212 bool result;
11213 byte temp2 ;
11214 int res2 = 0 ;
11215 byte temp3 ;
11216 int res3 = 0 ;
11217 byte temp4 ;
11218 int res4 = 0 ;
11219 PyObject * obj0 = 0 ;
11220 PyObject * obj1 = 0 ;
11221 PyObject * obj2 = 0 ;
11222 PyObject * obj3 = 0 ;
11223 char *kwnames[] = {
11224 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11225 };
11226
11227 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11228 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11229 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11232 if (SWIG_arg_fail(1)) SWIG_fail;
11233 if (obj1) {
11234 {
11235 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11236 if (SWIG_arg_fail(5)) SWIG_fail;
11237 }
11238 }
11239 if (obj2) {
11240 {
11241 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11242 if (SWIG_arg_fail(6)) SWIG_fail;
11243 }
11244 }
11245 if (obj3) {
11246 {
11247 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11248 if (SWIG_arg_fail(7)) SWIG_fail;
11249 }
11250 }
11251 {
11252 PyThreadState* __tstate = wxPyBeginAllowThreads();
11253 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11254
11255 wxPyEndAllowThreads(__tstate);
11256 if (PyErr_Occurred()) SWIG_fail;
11257 }
11258 {
11259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11260 }
11261 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11262 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11263 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11264 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11265 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11266 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11267 return resultobj;
11268 fail:
11269 return NULL;
11270 }
11271
11272
11273 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11274 PyObject *resultobj;
11275 wxImage *arg1 = (wxImage *) 0 ;
11276 byte arg2 = (byte) 128 ;
11277 bool result;
11278 PyObject * obj0 = 0 ;
11279 PyObject * obj1 = 0 ;
11280 char *kwnames[] = {
11281 (char *) "self",(char *) "threshold", NULL
11282 };
11283
11284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11286 if (SWIG_arg_fail(1)) SWIG_fail;
11287 if (obj1) {
11288 {
11289 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11290 if (SWIG_arg_fail(2)) SWIG_fail;
11291 }
11292 }
11293 {
11294 PyThreadState* __tstate = wxPyBeginAllowThreads();
11295 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11296
11297 wxPyEndAllowThreads(__tstate);
11298 if (PyErr_Occurred()) SWIG_fail;
11299 }
11300 {
11301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11302 }
11303 return resultobj;
11304 fail:
11305 return NULL;
11306 }
11307
11308
11309 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11310 PyObject *resultobj;
11311 wxImage *arg1 = (wxImage *) 0 ;
11312 unsigned char arg2 ;
11313 unsigned char arg3 ;
11314 unsigned char arg4 ;
11315 bool result;
11316 PyObject * obj0 = 0 ;
11317 PyObject * obj1 = 0 ;
11318 PyObject * obj2 = 0 ;
11319 PyObject * obj3 = 0 ;
11320 char *kwnames[] = {
11321 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11322 };
11323
11324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11326 if (SWIG_arg_fail(1)) SWIG_fail;
11327 {
11328 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11329 if (SWIG_arg_fail(2)) SWIG_fail;
11330 }
11331 {
11332 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11333 if (SWIG_arg_fail(3)) SWIG_fail;
11334 }
11335 {
11336 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11337 if (SWIG_arg_fail(4)) SWIG_fail;
11338 }
11339 {
11340 PyThreadState* __tstate = wxPyBeginAllowThreads();
11341 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11342
11343 wxPyEndAllowThreads(__tstate);
11344 if (PyErr_Occurred()) SWIG_fail;
11345 }
11346 {
11347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11348 }
11349 return resultobj;
11350 fail:
11351 return NULL;
11352 }
11353
11354
11355 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11356 PyObject *resultobj;
11357 wxImage *arg1 = (wxImage *) 0 ;
11358 wxImage *arg2 = 0 ;
11359 byte arg3 ;
11360 byte arg4 ;
11361 byte arg5 ;
11362 bool result;
11363 PyObject * obj0 = 0 ;
11364 PyObject * obj1 = 0 ;
11365 PyObject * obj2 = 0 ;
11366 PyObject * obj3 = 0 ;
11367 PyObject * obj4 = 0 ;
11368 char *kwnames[] = {
11369 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11370 };
11371
11372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11374 if (SWIG_arg_fail(1)) SWIG_fail;
11375 {
11376 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11377 if (SWIG_arg_fail(2)) SWIG_fail;
11378 if (arg2 == NULL) {
11379 SWIG_null_ref("wxImage");
11380 }
11381 if (SWIG_arg_fail(2)) SWIG_fail;
11382 }
11383 {
11384 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11385 if (SWIG_arg_fail(3)) SWIG_fail;
11386 }
11387 {
11388 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11389 if (SWIG_arg_fail(4)) SWIG_fail;
11390 }
11391 {
11392 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11393 if (SWIG_arg_fail(5)) SWIG_fail;
11394 }
11395 {
11396 PyThreadState* __tstate = wxPyBeginAllowThreads();
11397 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11398
11399 wxPyEndAllowThreads(__tstate);
11400 if (PyErr_Occurred()) SWIG_fail;
11401 }
11402 {
11403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11404 }
11405 return resultobj;
11406 fail:
11407 return NULL;
11408 }
11409
11410
11411 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11412 PyObject *resultobj;
11413 wxString *arg1 = 0 ;
11414 bool result;
11415 bool temp1 = false ;
11416 PyObject * obj0 = 0 ;
11417 char *kwnames[] = {
11418 (char *) "name", NULL
11419 };
11420
11421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11422 {
11423 arg1 = wxString_in_helper(obj0);
11424 if (arg1 == NULL) SWIG_fail;
11425 temp1 = true;
11426 }
11427 {
11428 PyThreadState* __tstate = wxPyBeginAllowThreads();
11429 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11430
11431 wxPyEndAllowThreads(__tstate);
11432 if (PyErr_Occurred()) SWIG_fail;
11433 }
11434 {
11435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11436 }
11437 {
11438 if (temp1)
11439 delete arg1;
11440 }
11441 return resultobj;
11442 fail:
11443 {
11444 if (temp1)
11445 delete arg1;
11446 }
11447 return NULL;
11448 }
11449
11450
11451 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11452 PyObject *resultobj;
11453 wxString *arg1 = 0 ;
11454 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11455 int result;
11456 bool temp1 = false ;
11457 PyObject * obj0 = 0 ;
11458 PyObject * obj1 = 0 ;
11459 char *kwnames[] = {
11460 (char *) "name",(char *) "type", NULL
11461 };
11462
11463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11464 {
11465 arg1 = wxString_in_helper(obj0);
11466 if (arg1 == NULL) SWIG_fail;
11467 temp1 = true;
11468 }
11469 if (obj1) {
11470 {
11471 arg2 = (long)(SWIG_As_long(obj1));
11472 if (SWIG_arg_fail(2)) SWIG_fail;
11473 }
11474 }
11475 {
11476 PyThreadState* __tstate = wxPyBeginAllowThreads();
11477 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11478
11479 wxPyEndAllowThreads(__tstate);
11480 if (PyErr_Occurred()) SWIG_fail;
11481 }
11482 {
11483 resultobj = SWIG_From_int((int)(result));
11484 }
11485 {
11486 if (temp1)
11487 delete arg1;
11488 }
11489 return resultobj;
11490 fail:
11491 {
11492 if (temp1)
11493 delete arg1;
11494 }
11495 return NULL;
11496 }
11497
11498
11499 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11500 PyObject *resultobj;
11501 wxImage *arg1 = (wxImage *) 0 ;
11502 wxString *arg2 = 0 ;
11503 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11504 int arg4 = (int) -1 ;
11505 bool result;
11506 bool temp2 = false ;
11507 PyObject * obj0 = 0 ;
11508 PyObject * obj1 = 0 ;
11509 PyObject * obj2 = 0 ;
11510 PyObject * obj3 = 0 ;
11511 char *kwnames[] = {
11512 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11513 };
11514
11515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11517 if (SWIG_arg_fail(1)) SWIG_fail;
11518 {
11519 arg2 = wxString_in_helper(obj1);
11520 if (arg2 == NULL) SWIG_fail;
11521 temp2 = true;
11522 }
11523 if (obj2) {
11524 {
11525 arg3 = (long)(SWIG_As_long(obj2));
11526 if (SWIG_arg_fail(3)) SWIG_fail;
11527 }
11528 }
11529 if (obj3) {
11530 {
11531 arg4 = (int)(SWIG_As_int(obj3));
11532 if (SWIG_arg_fail(4)) SWIG_fail;
11533 }
11534 }
11535 {
11536 PyThreadState* __tstate = wxPyBeginAllowThreads();
11537 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11538
11539 wxPyEndAllowThreads(__tstate);
11540 if (PyErr_Occurred()) SWIG_fail;
11541 }
11542 {
11543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11544 }
11545 {
11546 if (temp2)
11547 delete arg2;
11548 }
11549 return resultobj;
11550 fail:
11551 {
11552 if (temp2)
11553 delete arg2;
11554 }
11555 return NULL;
11556 }
11557
11558
11559 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11560 PyObject *resultobj;
11561 wxImage *arg1 = (wxImage *) 0 ;
11562 wxString *arg2 = 0 ;
11563 wxString *arg3 = 0 ;
11564 int arg4 = (int) -1 ;
11565 bool result;
11566 bool temp2 = false ;
11567 bool temp3 = false ;
11568 PyObject * obj0 = 0 ;
11569 PyObject * obj1 = 0 ;
11570 PyObject * obj2 = 0 ;
11571 PyObject * obj3 = 0 ;
11572 char *kwnames[] = {
11573 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11574 };
11575
11576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11578 if (SWIG_arg_fail(1)) SWIG_fail;
11579 {
11580 arg2 = wxString_in_helper(obj1);
11581 if (arg2 == NULL) SWIG_fail;
11582 temp2 = true;
11583 }
11584 {
11585 arg3 = wxString_in_helper(obj2);
11586 if (arg3 == NULL) SWIG_fail;
11587 temp3 = true;
11588 }
11589 if (obj3) {
11590 {
11591 arg4 = (int)(SWIG_As_int(obj3));
11592 if (SWIG_arg_fail(4)) SWIG_fail;
11593 }
11594 }
11595 {
11596 PyThreadState* __tstate = wxPyBeginAllowThreads();
11597 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11598
11599 wxPyEndAllowThreads(__tstate);
11600 if (PyErr_Occurred()) SWIG_fail;
11601 }
11602 {
11603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11604 }
11605 {
11606 if (temp2)
11607 delete arg2;
11608 }
11609 {
11610 if (temp3)
11611 delete arg3;
11612 }
11613 return resultobj;
11614 fail:
11615 {
11616 if (temp2)
11617 delete arg2;
11618 }
11619 {
11620 if (temp3)
11621 delete arg3;
11622 }
11623 return NULL;
11624 }
11625
11626
11627 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11628 PyObject *resultobj;
11629 wxImage *arg1 = (wxImage *) 0 ;
11630 wxString *arg2 = 0 ;
11631 int arg3 ;
11632 bool result;
11633 bool temp2 = false ;
11634 PyObject * obj0 = 0 ;
11635 PyObject * obj1 = 0 ;
11636 PyObject * obj2 = 0 ;
11637 char *kwnames[] = {
11638 (char *) "self",(char *) "name",(char *) "type", NULL
11639 };
11640
11641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11643 if (SWIG_arg_fail(1)) SWIG_fail;
11644 {
11645 arg2 = wxString_in_helper(obj1);
11646 if (arg2 == NULL) SWIG_fail;
11647 temp2 = true;
11648 }
11649 {
11650 arg3 = (int)(SWIG_As_int(obj2));
11651 if (SWIG_arg_fail(3)) SWIG_fail;
11652 }
11653 {
11654 PyThreadState* __tstate = wxPyBeginAllowThreads();
11655 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11656
11657 wxPyEndAllowThreads(__tstate);
11658 if (PyErr_Occurred()) SWIG_fail;
11659 }
11660 {
11661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11662 }
11663 {
11664 if (temp2)
11665 delete arg2;
11666 }
11667 return resultobj;
11668 fail:
11669 {
11670 if (temp2)
11671 delete arg2;
11672 }
11673 return NULL;
11674 }
11675
11676
11677 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11678 PyObject *resultobj;
11679 wxImage *arg1 = (wxImage *) 0 ;
11680 wxString *arg2 = 0 ;
11681 wxString *arg3 = 0 ;
11682 bool result;
11683 bool temp2 = false ;
11684 bool temp3 = false ;
11685 PyObject * obj0 = 0 ;
11686 PyObject * obj1 = 0 ;
11687 PyObject * obj2 = 0 ;
11688 char *kwnames[] = {
11689 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11690 };
11691
11692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11694 if (SWIG_arg_fail(1)) SWIG_fail;
11695 {
11696 arg2 = wxString_in_helper(obj1);
11697 if (arg2 == NULL) SWIG_fail;
11698 temp2 = true;
11699 }
11700 {
11701 arg3 = wxString_in_helper(obj2);
11702 if (arg3 == NULL) SWIG_fail;
11703 temp3 = true;
11704 }
11705 {
11706 PyThreadState* __tstate = wxPyBeginAllowThreads();
11707 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11708
11709 wxPyEndAllowThreads(__tstate);
11710 if (PyErr_Occurred()) SWIG_fail;
11711 }
11712 {
11713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11714 }
11715 {
11716 if (temp2)
11717 delete arg2;
11718 }
11719 {
11720 if (temp3)
11721 delete arg3;
11722 }
11723 return resultobj;
11724 fail:
11725 {
11726 if (temp2)
11727 delete arg2;
11728 }
11729 {
11730 if (temp3)
11731 delete arg3;
11732 }
11733 return NULL;
11734 }
11735
11736
11737 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11738 PyObject *resultobj;
11739 wxInputStream *arg1 = 0 ;
11740 bool result;
11741 wxPyInputStream *temp1 ;
11742 bool created1 ;
11743 PyObject * obj0 = 0 ;
11744 char *kwnames[] = {
11745 (char *) "stream", NULL
11746 };
11747
11748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11749 {
11750 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11751 arg1 = temp1->m_wxis;
11752 created1 = false;
11753 } else {
11754 PyErr_Clear(); // clear the failure of the wxPyConvert above
11755 arg1 = wxPyCBInputStream_create(obj0, false);
11756 if (arg1 == NULL) {
11757 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11758 SWIG_fail;
11759 }
11760 created1 = true;
11761 }
11762 }
11763 {
11764 PyThreadState* __tstate = wxPyBeginAllowThreads();
11765 result = (bool)wxImage::CanRead(*arg1);
11766
11767 wxPyEndAllowThreads(__tstate);
11768 if (PyErr_Occurred()) SWIG_fail;
11769 }
11770 {
11771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11772 }
11773 {
11774 if (created1)
11775 delete arg1;
11776 }
11777 return resultobj;
11778 fail:
11779 {
11780 if (created1)
11781 delete arg1;
11782 }
11783 return NULL;
11784 }
11785
11786
11787 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11788 PyObject *resultobj;
11789 wxImage *arg1 = (wxImage *) 0 ;
11790 wxInputStream *arg2 = 0 ;
11791 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11792 int arg4 = (int) -1 ;
11793 bool result;
11794 wxPyInputStream *temp2 ;
11795 bool created2 ;
11796 PyObject * obj0 = 0 ;
11797 PyObject * obj1 = 0 ;
11798 PyObject * obj2 = 0 ;
11799 PyObject * obj3 = 0 ;
11800 char *kwnames[] = {
11801 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11802 };
11803
11804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11806 if (SWIG_arg_fail(1)) SWIG_fail;
11807 {
11808 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11809 arg2 = temp2->m_wxis;
11810 created2 = false;
11811 } else {
11812 PyErr_Clear(); // clear the failure of the wxPyConvert above
11813 arg2 = wxPyCBInputStream_create(obj1, false);
11814 if (arg2 == NULL) {
11815 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11816 SWIG_fail;
11817 }
11818 created2 = true;
11819 }
11820 }
11821 if (obj2) {
11822 {
11823 arg3 = (long)(SWIG_As_long(obj2));
11824 if (SWIG_arg_fail(3)) SWIG_fail;
11825 }
11826 }
11827 if (obj3) {
11828 {
11829 arg4 = (int)(SWIG_As_int(obj3));
11830 if (SWIG_arg_fail(4)) SWIG_fail;
11831 }
11832 }
11833 {
11834 PyThreadState* __tstate = wxPyBeginAllowThreads();
11835 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
11836
11837 wxPyEndAllowThreads(__tstate);
11838 if (PyErr_Occurred()) SWIG_fail;
11839 }
11840 {
11841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11842 }
11843 {
11844 if (created2)
11845 delete arg2;
11846 }
11847 return resultobj;
11848 fail:
11849 {
11850 if (created2)
11851 delete arg2;
11852 }
11853 return NULL;
11854 }
11855
11856
11857 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
11858 PyObject *resultobj;
11859 wxImage *arg1 = (wxImage *) 0 ;
11860 wxInputStream *arg2 = 0 ;
11861 wxString *arg3 = 0 ;
11862 int arg4 = (int) -1 ;
11863 bool result;
11864 wxPyInputStream *temp2 ;
11865 bool created2 ;
11866 bool temp3 = false ;
11867 PyObject * obj0 = 0 ;
11868 PyObject * obj1 = 0 ;
11869 PyObject * obj2 = 0 ;
11870 PyObject * obj3 = 0 ;
11871 char *kwnames[] = {
11872 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
11873 };
11874
11875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11877 if (SWIG_arg_fail(1)) SWIG_fail;
11878 {
11879 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11880 arg2 = temp2->m_wxis;
11881 created2 = false;
11882 } else {
11883 PyErr_Clear(); // clear the failure of the wxPyConvert above
11884 arg2 = wxPyCBInputStream_create(obj1, false);
11885 if (arg2 == NULL) {
11886 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11887 SWIG_fail;
11888 }
11889 created2 = true;
11890 }
11891 }
11892 {
11893 arg3 = wxString_in_helper(obj2);
11894 if (arg3 == NULL) SWIG_fail;
11895 temp3 = true;
11896 }
11897 if (obj3) {
11898 {
11899 arg4 = (int)(SWIG_As_int(obj3));
11900 if (SWIG_arg_fail(4)) SWIG_fail;
11901 }
11902 }
11903 {
11904 PyThreadState* __tstate = wxPyBeginAllowThreads();
11905 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
11906
11907 wxPyEndAllowThreads(__tstate);
11908 if (PyErr_Occurred()) SWIG_fail;
11909 }
11910 {
11911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11912 }
11913 {
11914 if (created2)
11915 delete arg2;
11916 }
11917 {
11918 if (temp3)
11919 delete arg3;
11920 }
11921 return resultobj;
11922 fail:
11923 {
11924 if (created2)
11925 delete arg2;
11926 }
11927 {
11928 if (temp3)
11929 delete arg3;
11930 }
11931 return NULL;
11932 }
11933
11934
11935 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
11936 PyObject *resultobj;
11937 wxImage *arg1 = (wxImage *) 0 ;
11938 bool result;
11939 PyObject * obj0 = 0 ;
11940 char *kwnames[] = {
11941 (char *) "self", NULL
11942 };
11943
11944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
11945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11946 if (SWIG_arg_fail(1)) SWIG_fail;
11947 {
11948 PyThreadState* __tstate = wxPyBeginAllowThreads();
11949 result = (bool)(arg1)->Ok();
11950
11951 wxPyEndAllowThreads(__tstate);
11952 if (PyErr_Occurred()) SWIG_fail;
11953 }
11954 {
11955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11956 }
11957 return resultobj;
11958 fail:
11959 return NULL;
11960 }
11961
11962
11963 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
11964 PyObject *resultobj;
11965 wxImage *arg1 = (wxImage *) 0 ;
11966 int result;
11967 PyObject * obj0 = 0 ;
11968 char *kwnames[] = {
11969 (char *) "self", NULL
11970 };
11971
11972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
11973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11974 if (SWIG_arg_fail(1)) SWIG_fail;
11975 {
11976 PyThreadState* __tstate = wxPyBeginAllowThreads();
11977 result = (int)(arg1)->GetWidth();
11978
11979 wxPyEndAllowThreads(__tstate);
11980 if (PyErr_Occurred()) SWIG_fail;
11981 }
11982 {
11983 resultobj = SWIG_From_int((int)(result));
11984 }
11985 return resultobj;
11986 fail:
11987 return NULL;
11988 }
11989
11990
11991 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
11992 PyObject *resultobj;
11993 wxImage *arg1 = (wxImage *) 0 ;
11994 int result;
11995 PyObject * obj0 = 0 ;
11996 char *kwnames[] = {
11997 (char *) "self", NULL
11998 };
11999
12000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12002 if (SWIG_arg_fail(1)) SWIG_fail;
12003 {
12004 PyThreadState* __tstate = wxPyBeginAllowThreads();
12005 result = (int)(arg1)->GetHeight();
12006
12007 wxPyEndAllowThreads(__tstate);
12008 if (PyErr_Occurred()) SWIG_fail;
12009 }
12010 {
12011 resultobj = SWIG_From_int((int)(result));
12012 }
12013 return resultobj;
12014 fail:
12015 return NULL;
12016 }
12017
12018
12019 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12020 PyObject *resultobj;
12021 wxImage *arg1 = (wxImage *) 0 ;
12022 wxSize result;
12023 PyObject * obj0 = 0 ;
12024 char *kwnames[] = {
12025 (char *) "self", NULL
12026 };
12027
12028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12030 if (SWIG_arg_fail(1)) SWIG_fail;
12031 {
12032 PyThreadState* __tstate = wxPyBeginAllowThreads();
12033 result = wxImage_GetSize(arg1);
12034
12035 wxPyEndAllowThreads(__tstate);
12036 if (PyErr_Occurred()) SWIG_fail;
12037 }
12038 {
12039 wxSize * resultptr;
12040 resultptr = new wxSize((wxSize &)(result));
12041 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12042 }
12043 return resultobj;
12044 fail:
12045 return NULL;
12046 }
12047
12048
12049 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12050 PyObject *resultobj;
12051 wxImage *arg1 = (wxImage *) 0 ;
12052 wxRect *arg2 = 0 ;
12053 SwigValueWrapper<wxImage > result;
12054 wxRect temp2 ;
12055 PyObject * obj0 = 0 ;
12056 PyObject * obj1 = 0 ;
12057 char *kwnames[] = {
12058 (char *) "self",(char *) "rect", NULL
12059 };
12060
12061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12063 if (SWIG_arg_fail(1)) SWIG_fail;
12064 {
12065 arg2 = &temp2;
12066 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12067 }
12068 {
12069 PyThreadState* __tstate = wxPyBeginAllowThreads();
12070 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12071
12072 wxPyEndAllowThreads(__tstate);
12073 if (PyErr_Occurred()) SWIG_fail;
12074 }
12075 {
12076 wxImage * resultptr;
12077 resultptr = new wxImage((wxImage &)(result));
12078 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12079 }
12080 return resultobj;
12081 fail:
12082 return NULL;
12083 }
12084
12085
12086 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12087 PyObject *resultobj;
12088 wxImage *arg1 = (wxImage *) 0 ;
12089 SwigValueWrapper<wxImage > result;
12090 PyObject * obj0 = 0 ;
12091 char *kwnames[] = {
12092 (char *) "self", NULL
12093 };
12094
12095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12097 if (SWIG_arg_fail(1)) SWIG_fail;
12098 {
12099 PyThreadState* __tstate = wxPyBeginAllowThreads();
12100 result = (arg1)->Copy();
12101
12102 wxPyEndAllowThreads(__tstate);
12103 if (PyErr_Occurred()) SWIG_fail;
12104 }
12105 {
12106 wxImage * resultptr;
12107 resultptr = new wxImage((wxImage &)(result));
12108 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12109 }
12110 return resultobj;
12111 fail:
12112 return NULL;
12113 }
12114
12115
12116 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12117 PyObject *resultobj;
12118 wxImage *arg1 = (wxImage *) 0 ;
12119 wxImage *arg2 = 0 ;
12120 int arg3 ;
12121 int arg4 ;
12122 PyObject * obj0 = 0 ;
12123 PyObject * obj1 = 0 ;
12124 PyObject * obj2 = 0 ;
12125 PyObject * obj3 = 0 ;
12126 char *kwnames[] = {
12127 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12128 };
12129
12130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12132 if (SWIG_arg_fail(1)) SWIG_fail;
12133 {
12134 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12135 if (SWIG_arg_fail(2)) SWIG_fail;
12136 if (arg2 == NULL) {
12137 SWIG_null_ref("wxImage");
12138 }
12139 if (SWIG_arg_fail(2)) SWIG_fail;
12140 }
12141 {
12142 arg3 = (int)(SWIG_As_int(obj2));
12143 if (SWIG_arg_fail(3)) SWIG_fail;
12144 }
12145 {
12146 arg4 = (int)(SWIG_As_int(obj3));
12147 if (SWIG_arg_fail(4)) SWIG_fail;
12148 }
12149 {
12150 PyThreadState* __tstate = wxPyBeginAllowThreads();
12151 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12152
12153 wxPyEndAllowThreads(__tstate);
12154 if (PyErr_Occurred()) SWIG_fail;
12155 }
12156 Py_INCREF(Py_None); resultobj = Py_None;
12157 return resultobj;
12158 fail:
12159 return NULL;
12160 }
12161
12162
12163 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12164 PyObject *resultobj;
12165 wxImage *arg1 = (wxImage *) 0 ;
12166 PyObject *result;
12167 PyObject * obj0 = 0 ;
12168 char *kwnames[] = {
12169 (char *) "self", NULL
12170 };
12171
12172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12174 if (SWIG_arg_fail(1)) SWIG_fail;
12175 {
12176 PyThreadState* __tstate = wxPyBeginAllowThreads();
12177 result = (PyObject *)wxImage_GetData(arg1);
12178
12179 wxPyEndAllowThreads(__tstate);
12180 if (PyErr_Occurred()) SWIG_fail;
12181 }
12182 resultobj = result;
12183 return resultobj;
12184 fail:
12185 return NULL;
12186 }
12187
12188
12189 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12190 PyObject *resultobj;
12191 wxImage *arg1 = (wxImage *) 0 ;
12192 PyObject *arg2 = (PyObject *) 0 ;
12193 PyObject * obj0 = 0 ;
12194 PyObject * obj1 = 0 ;
12195 char *kwnames[] = {
12196 (char *) "self",(char *) "data", NULL
12197 };
12198
12199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12201 if (SWIG_arg_fail(1)) SWIG_fail;
12202 arg2 = obj1;
12203 {
12204 PyThreadState* __tstate = wxPyBeginAllowThreads();
12205 wxImage_SetData(arg1,arg2);
12206
12207 wxPyEndAllowThreads(__tstate);
12208 if (PyErr_Occurred()) SWIG_fail;
12209 }
12210 Py_INCREF(Py_None); resultobj = Py_None;
12211 return resultobj;
12212 fail:
12213 return NULL;
12214 }
12215
12216
12217 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12218 PyObject *resultobj;
12219 wxImage *arg1 = (wxImage *) 0 ;
12220 PyObject *result;
12221 PyObject * obj0 = 0 ;
12222 char *kwnames[] = {
12223 (char *) "self", NULL
12224 };
12225
12226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12228 if (SWIG_arg_fail(1)) SWIG_fail;
12229 {
12230 PyThreadState* __tstate = wxPyBeginAllowThreads();
12231 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12232
12233 wxPyEndAllowThreads(__tstate);
12234 if (PyErr_Occurred()) SWIG_fail;
12235 }
12236 resultobj = result;
12237 return resultobj;
12238 fail:
12239 return NULL;
12240 }
12241
12242
12243 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12244 PyObject *resultobj;
12245 wxImage *arg1 = (wxImage *) 0 ;
12246 PyObject *arg2 = (PyObject *) 0 ;
12247 PyObject * obj0 = 0 ;
12248 PyObject * obj1 = 0 ;
12249 char *kwnames[] = {
12250 (char *) "self",(char *) "data", NULL
12251 };
12252
12253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12255 if (SWIG_arg_fail(1)) SWIG_fail;
12256 arg2 = obj1;
12257 {
12258 PyThreadState* __tstate = wxPyBeginAllowThreads();
12259 wxImage_SetDataBuffer(arg1,arg2);
12260
12261 wxPyEndAllowThreads(__tstate);
12262 if (PyErr_Occurred()) SWIG_fail;
12263 }
12264 Py_INCREF(Py_None); resultobj = Py_None;
12265 return resultobj;
12266 fail:
12267 return NULL;
12268 }
12269
12270
12271 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12272 PyObject *resultobj;
12273 wxImage *arg1 = (wxImage *) 0 ;
12274 PyObject *result;
12275 PyObject * obj0 = 0 ;
12276 char *kwnames[] = {
12277 (char *) "self", NULL
12278 };
12279
12280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12282 if (SWIG_arg_fail(1)) SWIG_fail;
12283 {
12284 PyThreadState* __tstate = wxPyBeginAllowThreads();
12285 result = (PyObject *)wxImage_GetAlphaData(arg1);
12286
12287 wxPyEndAllowThreads(__tstate);
12288 if (PyErr_Occurred()) SWIG_fail;
12289 }
12290 resultobj = result;
12291 return resultobj;
12292 fail:
12293 return NULL;
12294 }
12295
12296
12297 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12298 PyObject *resultobj;
12299 wxImage *arg1 = (wxImage *) 0 ;
12300 PyObject *arg2 = (PyObject *) 0 ;
12301 PyObject * obj0 = 0 ;
12302 PyObject * obj1 = 0 ;
12303 char *kwnames[] = {
12304 (char *) "self",(char *) "data", NULL
12305 };
12306
12307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12309 if (SWIG_arg_fail(1)) SWIG_fail;
12310 arg2 = obj1;
12311 {
12312 PyThreadState* __tstate = wxPyBeginAllowThreads();
12313 wxImage_SetAlphaData(arg1,arg2);
12314
12315 wxPyEndAllowThreads(__tstate);
12316 if (PyErr_Occurred()) SWIG_fail;
12317 }
12318 Py_INCREF(Py_None); resultobj = Py_None;
12319 return resultobj;
12320 fail:
12321 return NULL;
12322 }
12323
12324
12325 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12326 PyObject *resultobj;
12327 wxImage *arg1 = (wxImage *) 0 ;
12328 PyObject *result;
12329 PyObject * obj0 = 0 ;
12330 char *kwnames[] = {
12331 (char *) "self", NULL
12332 };
12333
12334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12336 if (SWIG_arg_fail(1)) SWIG_fail;
12337 {
12338 PyThreadState* __tstate = wxPyBeginAllowThreads();
12339 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12340
12341 wxPyEndAllowThreads(__tstate);
12342 if (PyErr_Occurred()) SWIG_fail;
12343 }
12344 resultobj = result;
12345 return resultobj;
12346 fail:
12347 return NULL;
12348 }
12349
12350
12351 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12352 PyObject *resultobj;
12353 wxImage *arg1 = (wxImage *) 0 ;
12354 PyObject *arg2 = (PyObject *) 0 ;
12355 PyObject * obj0 = 0 ;
12356 PyObject * obj1 = 0 ;
12357 char *kwnames[] = {
12358 (char *) "self",(char *) "data", NULL
12359 };
12360
12361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12363 if (SWIG_arg_fail(1)) SWIG_fail;
12364 arg2 = obj1;
12365 {
12366 PyThreadState* __tstate = wxPyBeginAllowThreads();
12367 wxImage_SetAlphaBuffer(arg1,arg2);
12368
12369 wxPyEndAllowThreads(__tstate);
12370 if (PyErr_Occurred()) SWIG_fail;
12371 }
12372 Py_INCREF(Py_None); resultobj = Py_None;
12373 return resultobj;
12374 fail:
12375 return NULL;
12376 }
12377
12378
12379 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12380 PyObject *resultobj;
12381 wxImage *arg1 = (wxImage *) 0 ;
12382 unsigned char arg2 ;
12383 unsigned char arg3 ;
12384 unsigned char arg4 ;
12385 PyObject * obj0 = 0 ;
12386 PyObject * obj1 = 0 ;
12387 PyObject * obj2 = 0 ;
12388 PyObject * obj3 = 0 ;
12389 char *kwnames[] = {
12390 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12391 };
12392
12393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12395 if (SWIG_arg_fail(1)) SWIG_fail;
12396 {
12397 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12398 if (SWIG_arg_fail(2)) SWIG_fail;
12399 }
12400 {
12401 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12402 if (SWIG_arg_fail(3)) SWIG_fail;
12403 }
12404 {
12405 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12406 if (SWIG_arg_fail(4)) SWIG_fail;
12407 }
12408 {
12409 PyThreadState* __tstate = wxPyBeginAllowThreads();
12410 (arg1)->SetMaskColour(arg2,arg3,arg4);
12411
12412 wxPyEndAllowThreads(__tstate);
12413 if (PyErr_Occurred()) SWIG_fail;
12414 }
12415 Py_INCREF(Py_None); resultobj = Py_None;
12416 return resultobj;
12417 fail:
12418 return NULL;
12419 }
12420
12421
12422 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12423 PyObject *resultobj;
12424 wxImage *arg1 = (wxImage *) 0 ;
12425 unsigned char result;
12426 PyObject * obj0 = 0 ;
12427 char *kwnames[] = {
12428 (char *) "self", NULL
12429 };
12430
12431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12433 if (SWIG_arg_fail(1)) SWIG_fail;
12434 {
12435 PyThreadState* __tstate = wxPyBeginAllowThreads();
12436 result = (unsigned char)(arg1)->GetMaskRed();
12437
12438 wxPyEndAllowThreads(__tstate);
12439 if (PyErr_Occurred()) SWIG_fail;
12440 }
12441 {
12442 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12443 }
12444 return resultobj;
12445 fail:
12446 return NULL;
12447 }
12448
12449
12450 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12451 PyObject *resultobj;
12452 wxImage *arg1 = (wxImage *) 0 ;
12453 unsigned char result;
12454 PyObject * obj0 = 0 ;
12455 char *kwnames[] = {
12456 (char *) "self", NULL
12457 };
12458
12459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12461 if (SWIG_arg_fail(1)) SWIG_fail;
12462 {
12463 PyThreadState* __tstate = wxPyBeginAllowThreads();
12464 result = (unsigned char)(arg1)->GetMaskGreen();
12465
12466 wxPyEndAllowThreads(__tstate);
12467 if (PyErr_Occurred()) SWIG_fail;
12468 }
12469 {
12470 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12471 }
12472 return resultobj;
12473 fail:
12474 return NULL;
12475 }
12476
12477
12478 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12479 PyObject *resultobj;
12480 wxImage *arg1 = (wxImage *) 0 ;
12481 unsigned char result;
12482 PyObject * obj0 = 0 ;
12483 char *kwnames[] = {
12484 (char *) "self", NULL
12485 };
12486
12487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12489 if (SWIG_arg_fail(1)) SWIG_fail;
12490 {
12491 PyThreadState* __tstate = wxPyBeginAllowThreads();
12492 result = (unsigned char)(arg1)->GetMaskBlue();
12493
12494 wxPyEndAllowThreads(__tstate);
12495 if (PyErr_Occurred()) SWIG_fail;
12496 }
12497 {
12498 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12499 }
12500 return resultobj;
12501 fail:
12502 return NULL;
12503 }
12504
12505
12506 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12507 PyObject *resultobj;
12508 wxImage *arg1 = (wxImage *) 0 ;
12509 bool arg2 = (bool) true ;
12510 PyObject * obj0 = 0 ;
12511 PyObject * obj1 = 0 ;
12512 char *kwnames[] = {
12513 (char *) "self",(char *) "mask", NULL
12514 };
12515
12516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12518 if (SWIG_arg_fail(1)) SWIG_fail;
12519 if (obj1) {
12520 {
12521 arg2 = (bool)(SWIG_As_bool(obj1));
12522 if (SWIG_arg_fail(2)) SWIG_fail;
12523 }
12524 }
12525 {
12526 PyThreadState* __tstate = wxPyBeginAllowThreads();
12527 (arg1)->SetMask(arg2);
12528
12529 wxPyEndAllowThreads(__tstate);
12530 if (PyErr_Occurred()) SWIG_fail;
12531 }
12532 Py_INCREF(Py_None); resultobj = Py_None;
12533 return resultobj;
12534 fail:
12535 return NULL;
12536 }
12537
12538
12539 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12540 PyObject *resultobj;
12541 wxImage *arg1 = (wxImage *) 0 ;
12542 bool result;
12543 PyObject * obj0 = 0 ;
12544 char *kwnames[] = {
12545 (char *) "self", NULL
12546 };
12547
12548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12550 if (SWIG_arg_fail(1)) SWIG_fail;
12551 {
12552 PyThreadState* __tstate = wxPyBeginAllowThreads();
12553 result = (bool)(arg1)->HasMask();
12554
12555 wxPyEndAllowThreads(__tstate);
12556 if (PyErr_Occurred()) SWIG_fail;
12557 }
12558 {
12559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12560 }
12561 return resultobj;
12562 fail:
12563 return NULL;
12564 }
12565
12566
12567 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12568 PyObject *resultobj;
12569 wxImage *arg1 = (wxImage *) 0 ;
12570 double arg2 ;
12571 wxPoint *arg3 = 0 ;
12572 bool arg4 = (bool) true ;
12573 wxPoint *arg5 = (wxPoint *) NULL ;
12574 SwigValueWrapper<wxImage > result;
12575 wxPoint temp3 ;
12576 PyObject * obj0 = 0 ;
12577 PyObject * obj1 = 0 ;
12578 PyObject * obj2 = 0 ;
12579 PyObject * obj3 = 0 ;
12580 PyObject * obj4 = 0 ;
12581 char *kwnames[] = {
12582 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12583 };
12584
12585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12587 if (SWIG_arg_fail(1)) SWIG_fail;
12588 {
12589 arg2 = (double)(SWIG_As_double(obj1));
12590 if (SWIG_arg_fail(2)) SWIG_fail;
12591 }
12592 {
12593 arg3 = &temp3;
12594 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12595 }
12596 if (obj3) {
12597 {
12598 arg4 = (bool)(SWIG_As_bool(obj3));
12599 if (SWIG_arg_fail(4)) SWIG_fail;
12600 }
12601 }
12602 if (obj4) {
12603 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12604 if (SWIG_arg_fail(5)) SWIG_fail;
12605 }
12606 {
12607 PyThreadState* __tstate = wxPyBeginAllowThreads();
12608 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12609
12610 wxPyEndAllowThreads(__tstate);
12611 if (PyErr_Occurred()) SWIG_fail;
12612 }
12613 {
12614 wxImage * resultptr;
12615 resultptr = new wxImage((wxImage &)(result));
12616 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12617 }
12618 return resultobj;
12619 fail:
12620 return NULL;
12621 }
12622
12623
12624 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12625 PyObject *resultobj;
12626 wxImage *arg1 = (wxImage *) 0 ;
12627 bool arg2 = (bool) true ;
12628 SwigValueWrapper<wxImage > result;
12629 PyObject * obj0 = 0 ;
12630 PyObject * obj1 = 0 ;
12631 char *kwnames[] = {
12632 (char *) "self",(char *) "clockwise", NULL
12633 };
12634
12635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12637 if (SWIG_arg_fail(1)) SWIG_fail;
12638 if (obj1) {
12639 {
12640 arg2 = (bool)(SWIG_As_bool(obj1));
12641 if (SWIG_arg_fail(2)) SWIG_fail;
12642 }
12643 }
12644 {
12645 PyThreadState* __tstate = wxPyBeginAllowThreads();
12646 result = (arg1)->Rotate90(arg2);
12647
12648 wxPyEndAllowThreads(__tstate);
12649 if (PyErr_Occurred()) SWIG_fail;
12650 }
12651 {
12652 wxImage * resultptr;
12653 resultptr = new wxImage((wxImage &)(result));
12654 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12655 }
12656 return resultobj;
12657 fail:
12658 return NULL;
12659 }
12660
12661
12662 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12663 PyObject *resultobj;
12664 wxImage *arg1 = (wxImage *) 0 ;
12665 bool arg2 = (bool) true ;
12666 SwigValueWrapper<wxImage > result;
12667 PyObject * obj0 = 0 ;
12668 PyObject * obj1 = 0 ;
12669 char *kwnames[] = {
12670 (char *) "self",(char *) "horizontally", NULL
12671 };
12672
12673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12675 if (SWIG_arg_fail(1)) SWIG_fail;
12676 if (obj1) {
12677 {
12678 arg2 = (bool)(SWIG_As_bool(obj1));
12679 if (SWIG_arg_fail(2)) SWIG_fail;
12680 }
12681 }
12682 {
12683 PyThreadState* __tstate = wxPyBeginAllowThreads();
12684 result = (arg1)->Mirror(arg2);
12685
12686 wxPyEndAllowThreads(__tstate);
12687 if (PyErr_Occurred()) SWIG_fail;
12688 }
12689 {
12690 wxImage * resultptr;
12691 resultptr = new wxImage((wxImage &)(result));
12692 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12693 }
12694 return resultobj;
12695 fail:
12696 return NULL;
12697 }
12698
12699
12700 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12701 PyObject *resultobj;
12702 wxImage *arg1 = (wxImage *) 0 ;
12703 unsigned char arg2 ;
12704 unsigned char arg3 ;
12705 unsigned char arg4 ;
12706 unsigned char arg5 ;
12707 unsigned char arg6 ;
12708 unsigned char arg7 ;
12709 PyObject * obj0 = 0 ;
12710 PyObject * obj1 = 0 ;
12711 PyObject * obj2 = 0 ;
12712 PyObject * obj3 = 0 ;
12713 PyObject * obj4 = 0 ;
12714 PyObject * obj5 = 0 ;
12715 PyObject * obj6 = 0 ;
12716 char *kwnames[] = {
12717 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12718 };
12719
12720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12722 if (SWIG_arg_fail(1)) SWIG_fail;
12723 {
12724 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12725 if (SWIG_arg_fail(2)) SWIG_fail;
12726 }
12727 {
12728 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12729 if (SWIG_arg_fail(3)) SWIG_fail;
12730 }
12731 {
12732 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12733 if (SWIG_arg_fail(4)) SWIG_fail;
12734 }
12735 {
12736 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
12737 if (SWIG_arg_fail(5)) SWIG_fail;
12738 }
12739 {
12740 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
12741 if (SWIG_arg_fail(6)) SWIG_fail;
12742 }
12743 {
12744 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
12745 if (SWIG_arg_fail(7)) SWIG_fail;
12746 }
12747 {
12748 PyThreadState* __tstate = wxPyBeginAllowThreads();
12749 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
12750
12751 wxPyEndAllowThreads(__tstate);
12752 if (PyErr_Occurred()) SWIG_fail;
12753 }
12754 Py_INCREF(Py_None); resultobj = Py_None;
12755 return resultobj;
12756 fail:
12757 return NULL;
12758 }
12759
12760
12761 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
12762 PyObject *resultobj;
12763 wxImage *arg1 = (wxImage *) 0 ;
12764 unsigned char arg2 ;
12765 unsigned char arg3 ;
12766 unsigned char arg4 ;
12767 SwigValueWrapper<wxImage > result;
12768 PyObject * obj0 = 0 ;
12769 PyObject * obj1 = 0 ;
12770 PyObject * obj2 = 0 ;
12771 PyObject * obj3 = 0 ;
12772 char *kwnames[] = {
12773 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12774 };
12775
12776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12778 if (SWIG_arg_fail(1)) SWIG_fail;
12779 {
12780 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12781 if (SWIG_arg_fail(2)) SWIG_fail;
12782 }
12783 {
12784 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12785 if (SWIG_arg_fail(3)) SWIG_fail;
12786 }
12787 {
12788 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12789 if (SWIG_arg_fail(4)) SWIG_fail;
12790 }
12791 {
12792 PyThreadState* __tstate = wxPyBeginAllowThreads();
12793 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
12794
12795 wxPyEndAllowThreads(__tstate);
12796 if (PyErr_Occurred()) SWIG_fail;
12797 }
12798 {
12799 wxImage * resultptr;
12800 resultptr = new wxImage((wxImage &)(result));
12801 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12802 }
12803 return resultobj;
12804 fail:
12805 return NULL;
12806 }
12807
12808
12809 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12810 PyObject *resultobj;
12811 wxImage *arg1 = (wxImage *) 0 ;
12812 wxString *arg2 = 0 ;
12813 wxString *arg3 = 0 ;
12814 bool temp2 = false ;
12815 bool temp3 = false ;
12816 PyObject * obj0 = 0 ;
12817 PyObject * obj1 = 0 ;
12818 PyObject * obj2 = 0 ;
12819 char *kwnames[] = {
12820 (char *) "self",(char *) "name",(char *) "value", NULL
12821 };
12822
12823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
12824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12825 if (SWIG_arg_fail(1)) SWIG_fail;
12826 {
12827 arg2 = wxString_in_helper(obj1);
12828 if (arg2 == NULL) SWIG_fail;
12829 temp2 = true;
12830 }
12831 {
12832 arg3 = wxString_in_helper(obj2);
12833 if (arg3 == NULL) SWIG_fail;
12834 temp3 = true;
12835 }
12836 {
12837 PyThreadState* __tstate = wxPyBeginAllowThreads();
12838 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
12839
12840 wxPyEndAllowThreads(__tstate);
12841 if (PyErr_Occurred()) SWIG_fail;
12842 }
12843 Py_INCREF(Py_None); resultobj = Py_None;
12844 {
12845 if (temp2)
12846 delete arg2;
12847 }
12848 {
12849 if (temp3)
12850 delete arg3;
12851 }
12852 return resultobj;
12853 fail:
12854 {
12855 if (temp2)
12856 delete arg2;
12857 }
12858 {
12859 if (temp3)
12860 delete arg3;
12861 }
12862 return NULL;
12863 }
12864
12865
12866 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12867 PyObject *resultobj;
12868 wxImage *arg1 = (wxImage *) 0 ;
12869 wxString *arg2 = 0 ;
12870 int arg3 ;
12871 bool temp2 = false ;
12872 PyObject * obj0 = 0 ;
12873 PyObject * obj1 = 0 ;
12874 PyObject * obj2 = 0 ;
12875 char *kwnames[] = {
12876 (char *) "self",(char *) "name",(char *) "value", NULL
12877 };
12878
12879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
12880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12881 if (SWIG_arg_fail(1)) SWIG_fail;
12882 {
12883 arg2 = wxString_in_helper(obj1);
12884 if (arg2 == NULL) SWIG_fail;
12885 temp2 = true;
12886 }
12887 {
12888 arg3 = (int)(SWIG_As_int(obj2));
12889 if (SWIG_arg_fail(3)) SWIG_fail;
12890 }
12891 {
12892 PyThreadState* __tstate = wxPyBeginAllowThreads();
12893 (arg1)->SetOption((wxString const &)*arg2,arg3);
12894
12895 wxPyEndAllowThreads(__tstate);
12896 if (PyErr_Occurred()) SWIG_fail;
12897 }
12898 Py_INCREF(Py_None); resultobj = Py_None;
12899 {
12900 if (temp2)
12901 delete arg2;
12902 }
12903 return resultobj;
12904 fail:
12905 {
12906 if (temp2)
12907 delete arg2;
12908 }
12909 return NULL;
12910 }
12911
12912
12913 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12914 PyObject *resultobj;
12915 wxImage *arg1 = (wxImage *) 0 ;
12916 wxString *arg2 = 0 ;
12917 wxString result;
12918 bool temp2 = false ;
12919 PyObject * obj0 = 0 ;
12920 PyObject * obj1 = 0 ;
12921 char *kwnames[] = {
12922 (char *) "self",(char *) "name", NULL
12923 };
12924
12925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
12926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12927 if (SWIG_arg_fail(1)) SWIG_fail;
12928 {
12929 arg2 = wxString_in_helper(obj1);
12930 if (arg2 == NULL) SWIG_fail;
12931 temp2 = true;
12932 }
12933 {
12934 PyThreadState* __tstate = wxPyBeginAllowThreads();
12935 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
12936
12937 wxPyEndAllowThreads(__tstate);
12938 if (PyErr_Occurred()) SWIG_fail;
12939 }
12940 {
12941 #if wxUSE_UNICODE
12942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12943 #else
12944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12945 #endif
12946 }
12947 {
12948 if (temp2)
12949 delete arg2;
12950 }
12951 return resultobj;
12952 fail:
12953 {
12954 if (temp2)
12955 delete arg2;
12956 }
12957 return NULL;
12958 }
12959
12960
12961 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12962 PyObject *resultobj;
12963 wxImage *arg1 = (wxImage *) 0 ;
12964 wxString *arg2 = 0 ;
12965 int result;
12966 bool temp2 = false ;
12967 PyObject * obj0 = 0 ;
12968 PyObject * obj1 = 0 ;
12969 char *kwnames[] = {
12970 (char *) "self",(char *) "name", NULL
12971 };
12972
12973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
12974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12975 if (SWIG_arg_fail(1)) SWIG_fail;
12976 {
12977 arg2 = wxString_in_helper(obj1);
12978 if (arg2 == NULL) SWIG_fail;
12979 temp2 = true;
12980 }
12981 {
12982 PyThreadState* __tstate = wxPyBeginAllowThreads();
12983 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
12984
12985 wxPyEndAllowThreads(__tstate);
12986 if (PyErr_Occurred()) SWIG_fail;
12987 }
12988 {
12989 resultobj = SWIG_From_int((int)(result));
12990 }
12991 {
12992 if (temp2)
12993 delete arg2;
12994 }
12995 return resultobj;
12996 fail:
12997 {
12998 if (temp2)
12999 delete arg2;
13000 }
13001 return NULL;
13002 }
13003
13004
13005 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13006 PyObject *resultobj;
13007 wxImage *arg1 = (wxImage *) 0 ;
13008 wxString *arg2 = 0 ;
13009 bool result;
13010 bool temp2 = false ;
13011 PyObject * obj0 = 0 ;
13012 PyObject * obj1 = 0 ;
13013 char *kwnames[] = {
13014 (char *) "self",(char *) "name", NULL
13015 };
13016
13017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13019 if (SWIG_arg_fail(1)) SWIG_fail;
13020 {
13021 arg2 = wxString_in_helper(obj1);
13022 if (arg2 == NULL) SWIG_fail;
13023 temp2 = true;
13024 }
13025 {
13026 PyThreadState* __tstate = wxPyBeginAllowThreads();
13027 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13028
13029 wxPyEndAllowThreads(__tstate);
13030 if (PyErr_Occurred()) SWIG_fail;
13031 }
13032 {
13033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13034 }
13035 {
13036 if (temp2)
13037 delete arg2;
13038 }
13039 return resultobj;
13040 fail:
13041 {
13042 if (temp2)
13043 delete arg2;
13044 }
13045 return NULL;
13046 }
13047
13048
13049 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13050 PyObject *resultobj;
13051 wxImage *arg1 = (wxImage *) 0 ;
13052 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13053 unsigned long result;
13054 PyObject * obj0 = 0 ;
13055 PyObject * obj1 = 0 ;
13056 char *kwnames[] = {
13057 (char *) "self",(char *) "stopafter", NULL
13058 };
13059
13060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13062 if (SWIG_arg_fail(1)) SWIG_fail;
13063 if (obj1) {
13064 {
13065 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13066 if (SWIG_arg_fail(2)) SWIG_fail;
13067 }
13068 }
13069 {
13070 PyThreadState* __tstate = wxPyBeginAllowThreads();
13071 result = (unsigned long)(arg1)->CountColours(arg2);
13072
13073 wxPyEndAllowThreads(__tstate);
13074 if (PyErr_Occurred()) SWIG_fail;
13075 }
13076 {
13077 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13078 }
13079 return resultobj;
13080 fail:
13081 return NULL;
13082 }
13083
13084
13085 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13086 PyObject *resultobj;
13087 wxImage *arg1 = (wxImage *) 0 ;
13088 wxImageHistogram *arg2 = 0 ;
13089 unsigned long result;
13090 PyObject * obj0 = 0 ;
13091 PyObject * obj1 = 0 ;
13092 char *kwnames[] = {
13093 (char *) "self",(char *) "h", NULL
13094 };
13095
13096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13098 if (SWIG_arg_fail(1)) SWIG_fail;
13099 {
13100 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13101 if (SWIG_arg_fail(2)) SWIG_fail;
13102 if (arg2 == NULL) {
13103 SWIG_null_ref("wxImageHistogram");
13104 }
13105 if (SWIG_arg_fail(2)) SWIG_fail;
13106 }
13107 {
13108 PyThreadState* __tstate = wxPyBeginAllowThreads();
13109 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13110
13111 wxPyEndAllowThreads(__tstate);
13112 if (PyErr_Occurred()) SWIG_fail;
13113 }
13114 {
13115 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13116 }
13117 return resultobj;
13118 fail:
13119 return NULL;
13120 }
13121
13122
13123 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13124 PyObject *resultobj;
13125 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13126 PyObject * obj0 = 0 ;
13127 char *kwnames[] = {
13128 (char *) "handler", NULL
13129 };
13130
13131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13133 if (SWIG_arg_fail(1)) SWIG_fail;
13134 {
13135 PyThreadState* __tstate = wxPyBeginAllowThreads();
13136 wxImage::AddHandler(arg1);
13137
13138 wxPyEndAllowThreads(__tstate);
13139 if (PyErr_Occurred()) SWIG_fail;
13140 }
13141 Py_INCREF(Py_None); resultobj = Py_None;
13142 return resultobj;
13143 fail:
13144 return NULL;
13145 }
13146
13147
13148 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13149 PyObject *resultobj;
13150 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13151 PyObject * obj0 = 0 ;
13152 char *kwnames[] = {
13153 (char *) "handler", NULL
13154 };
13155
13156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13158 if (SWIG_arg_fail(1)) SWIG_fail;
13159 {
13160 PyThreadState* __tstate = wxPyBeginAllowThreads();
13161 wxImage::InsertHandler(arg1);
13162
13163 wxPyEndAllowThreads(__tstate);
13164 if (PyErr_Occurred()) SWIG_fail;
13165 }
13166 Py_INCREF(Py_None); resultobj = Py_None;
13167 return resultobj;
13168 fail:
13169 return NULL;
13170 }
13171
13172
13173 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13174 PyObject *resultobj;
13175 wxString *arg1 = 0 ;
13176 bool result;
13177 bool temp1 = false ;
13178 PyObject * obj0 = 0 ;
13179 char *kwnames[] = {
13180 (char *) "name", NULL
13181 };
13182
13183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13184 {
13185 arg1 = wxString_in_helper(obj0);
13186 if (arg1 == NULL) SWIG_fail;
13187 temp1 = true;
13188 }
13189 {
13190 PyThreadState* __tstate = wxPyBeginAllowThreads();
13191 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13192
13193 wxPyEndAllowThreads(__tstate);
13194 if (PyErr_Occurred()) SWIG_fail;
13195 }
13196 {
13197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13198 }
13199 {
13200 if (temp1)
13201 delete arg1;
13202 }
13203 return resultobj;
13204 fail:
13205 {
13206 if (temp1)
13207 delete arg1;
13208 }
13209 return NULL;
13210 }
13211
13212
13213 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13214 PyObject *resultobj;
13215 wxString result;
13216 char *kwnames[] = {
13217 NULL
13218 };
13219
13220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13221 {
13222 PyThreadState* __tstate = wxPyBeginAllowThreads();
13223 result = wxImage::GetImageExtWildcard();
13224
13225 wxPyEndAllowThreads(__tstate);
13226 if (PyErr_Occurred()) SWIG_fail;
13227 }
13228 {
13229 #if wxUSE_UNICODE
13230 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13231 #else
13232 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13233 #endif
13234 }
13235 return resultobj;
13236 fail:
13237 return NULL;
13238 }
13239
13240
13241 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13242 PyObject *resultobj;
13243 wxImage *arg1 = (wxImage *) 0 ;
13244 int arg2 = (int) -1 ;
13245 wxBitmap result;
13246 PyObject * obj0 = 0 ;
13247 PyObject * obj1 = 0 ;
13248 char *kwnames[] = {
13249 (char *) "self",(char *) "depth", NULL
13250 };
13251
13252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13254 if (SWIG_arg_fail(1)) SWIG_fail;
13255 if (obj1) {
13256 {
13257 arg2 = (int)(SWIG_As_int(obj1));
13258 if (SWIG_arg_fail(2)) SWIG_fail;
13259 }
13260 }
13261 {
13262 if (!wxPyCheckForApp()) SWIG_fail;
13263 PyThreadState* __tstate = wxPyBeginAllowThreads();
13264 result = wxImage_ConvertToBitmap(arg1,arg2);
13265
13266 wxPyEndAllowThreads(__tstate);
13267 if (PyErr_Occurred()) SWIG_fail;
13268 }
13269 {
13270 wxBitmap * resultptr;
13271 resultptr = new wxBitmap((wxBitmap &)(result));
13272 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13273 }
13274 return resultobj;
13275 fail:
13276 return NULL;
13277 }
13278
13279
13280 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13281 PyObject *resultobj;
13282 wxImage *arg1 = (wxImage *) 0 ;
13283 unsigned char arg2 ;
13284 unsigned char arg3 ;
13285 unsigned char arg4 ;
13286 wxBitmap result;
13287 PyObject * obj0 = 0 ;
13288 PyObject * obj1 = 0 ;
13289 PyObject * obj2 = 0 ;
13290 PyObject * obj3 = 0 ;
13291 char *kwnames[] = {
13292 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13293 };
13294
13295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13297 if (SWIG_arg_fail(1)) SWIG_fail;
13298 {
13299 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13300 if (SWIG_arg_fail(2)) SWIG_fail;
13301 }
13302 {
13303 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13304 if (SWIG_arg_fail(3)) SWIG_fail;
13305 }
13306 {
13307 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13308 if (SWIG_arg_fail(4)) SWIG_fail;
13309 }
13310 {
13311 if (!wxPyCheckForApp()) SWIG_fail;
13312 PyThreadState* __tstate = wxPyBeginAllowThreads();
13313 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13314
13315 wxPyEndAllowThreads(__tstate);
13316 if (PyErr_Occurred()) SWIG_fail;
13317 }
13318 {
13319 wxBitmap * resultptr;
13320 resultptr = new wxBitmap((wxBitmap &)(result));
13321 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13322 }
13323 return resultobj;
13324 fail:
13325 return NULL;
13326 }
13327
13328
13329 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13330 PyObject *obj;
13331 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13332 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13333 Py_INCREF(obj);
13334 return Py_BuildValue((char *)"");
13335 }
13336 static int _wrap_NullImage_set(PyObject *) {
13337 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13338 return 1;
13339 }
13340
13341
13342 static PyObject *_wrap_NullImage_get(void) {
13343 PyObject *pyobj;
13344
13345 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13346 return pyobj;
13347 }
13348
13349
13350 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13351 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13352 return 1;
13353 }
13354
13355
13356 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13357 PyObject *pyobj;
13358
13359 {
13360 #if wxUSE_UNICODE
13361 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13362 #else
13363 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13364 #endif
13365 }
13366 return pyobj;
13367 }
13368
13369
13370 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13371 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13372 return 1;
13373 }
13374
13375
13376 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13377 PyObject *pyobj;
13378
13379 {
13380 #if wxUSE_UNICODE
13381 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13382 #else
13383 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13384 #endif
13385 }
13386 return pyobj;
13387 }
13388
13389
13390 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13391 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13392 return 1;
13393 }
13394
13395
13396 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13397 PyObject *pyobj;
13398
13399 {
13400 #if wxUSE_UNICODE
13401 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13402 #else
13403 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13404 #endif
13405 }
13406 return pyobj;
13407 }
13408
13409
13410 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13411 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13412 return 1;
13413 }
13414
13415
13416 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13417 PyObject *pyobj;
13418
13419 {
13420 #if wxUSE_UNICODE
13421 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13422 #else
13423 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13424 #endif
13425 }
13426 return pyobj;
13427 }
13428
13429
13430 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13431 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13432 return 1;
13433 }
13434
13435
13436 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13437 PyObject *pyobj;
13438
13439 {
13440 #if wxUSE_UNICODE
13441 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13442 #else
13443 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13444 #endif
13445 }
13446 return pyobj;
13447 }
13448
13449
13450 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13451 PyObject *resultobj;
13452 wxBMPHandler *result;
13453 char *kwnames[] = {
13454 NULL
13455 };
13456
13457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13458 {
13459 PyThreadState* __tstate = wxPyBeginAllowThreads();
13460 result = (wxBMPHandler *)new wxBMPHandler();
13461
13462 wxPyEndAllowThreads(__tstate);
13463 if (PyErr_Occurred()) SWIG_fail;
13464 }
13465 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13466 return resultobj;
13467 fail:
13468 return NULL;
13469 }
13470
13471
13472 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13473 PyObject *obj;
13474 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13475 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13476 Py_INCREF(obj);
13477 return Py_BuildValue((char *)"");
13478 }
13479 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13480 PyObject *resultobj;
13481 wxICOHandler *result;
13482 char *kwnames[] = {
13483 NULL
13484 };
13485
13486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13487 {
13488 PyThreadState* __tstate = wxPyBeginAllowThreads();
13489 result = (wxICOHandler *)new wxICOHandler();
13490
13491 wxPyEndAllowThreads(__tstate);
13492 if (PyErr_Occurred()) SWIG_fail;
13493 }
13494 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13495 return resultobj;
13496 fail:
13497 return NULL;
13498 }
13499
13500
13501 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13502 PyObject *obj;
13503 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13504 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13505 Py_INCREF(obj);
13506 return Py_BuildValue((char *)"");
13507 }
13508 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13509 PyObject *resultobj;
13510 wxCURHandler *result;
13511 char *kwnames[] = {
13512 NULL
13513 };
13514
13515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13516 {
13517 PyThreadState* __tstate = wxPyBeginAllowThreads();
13518 result = (wxCURHandler *)new wxCURHandler();
13519
13520 wxPyEndAllowThreads(__tstate);
13521 if (PyErr_Occurred()) SWIG_fail;
13522 }
13523 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13524 return resultobj;
13525 fail:
13526 return NULL;
13527 }
13528
13529
13530 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
13531 PyObject *obj;
13532 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13533 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
13534 Py_INCREF(obj);
13535 return Py_BuildValue((char *)"");
13536 }
13537 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13538 PyObject *resultobj;
13539 wxANIHandler *result;
13540 char *kwnames[] = {
13541 NULL
13542 };
13543
13544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
13545 {
13546 PyThreadState* __tstate = wxPyBeginAllowThreads();
13547 result = (wxANIHandler *)new wxANIHandler();
13548
13549 wxPyEndAllowThreads(__tstate);
13550 if (PyErr_Occurred()) SWIG_fail;
13551 }
13552 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
13553 return resultobj;
13554 fail:
13555 return NULL;
13556 }
13557
13558
13559 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
13560 PyObject *obj;
13561 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13562 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
13563 Py_INCREF(obj);
13564 return Py_BuildValue((char *)"");
13565 }
13566 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13567 PyObject *resultobj;
13568 wxPNGHandler *result;
13569 char *kwnames[] = {
13570 NULL
13571 };
13572
13573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
13574 {
13575 PyThreadState* __tstate = wxPyBeginAllowThreads();
13576 result = (wxPNGHandler *)new wxPNGHandler();
13577
13578 wxPyEndAllowThreads(__tstate);
13579 if (PyErr_Occurred()) SWIG_fail;
13580 }
13581 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
13582 return resultobj;
13583 fail:
13584 return NULL;
13585 }
13586
13587
13588 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
13589 PyObject *obj;
13590 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13591 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
13592 Py_INCREF(obj);
13593 return Py_BuildValue((char *)"");
13594 }
13595 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13596 PyObject *resultobj;
13597 wxGIFHandler *result;
13598 char *kwnames[] = {
13599 NULL
13600 };
13601
13602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
13603 {
13604 PyThreadState* __tstate = wxPyBeginAllowThreads();
13605 result = (wxGIFHandler *)new wxGIFHandler();
13606
13607 wxPyEndAllowThreads(__tstate);
13608 if (PyErr_Occurred()) SWIG_fail;
13609 }
13610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
13611 return resultobj;
13612 fail:
13613 return NULL;
13614 }
13615
13616
13617 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
13618 PyObject *obj;
13619 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13620 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
13621 Py_INCREF(obj);
13622 return Py_BuildValue((char *)"");
13623 }
13624 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13625 PyObject *resultobj;
13626 wxPCXHandler *result;
13627 char *kwnames[] = {
13628 NULL
13629 };
13630
13631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
13632 {
13633 PyThreadState* __tstate = wxPyBeginAllowThreads();
13634 result = (wxPCXHandler *)new wxPCXHandler();
13635
13636 wxPyEndAllowThreads(__tstate);
13637 if (PyErr_Occurred()) SWIG_fail;
13638 }
13639 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
13640 return resultobj;
13641 fail:
13642 return NULL;
13643 }
13644
13645
13646 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
13647 PyObject *obj;
13648 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13649 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
13650 Py_INCREF(obj);
13651 return Py_BuildValue((char *)"");
13652 }
13653 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13654 PyObject *resultobj;
13655 wxJPEGHandler *result;
13656 char *kwnames[] = {
13657 NULL
13658 };
13659
13660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
13661 {
13662 PyThreadState* __tstate = wxPyBeginAllowThreads();
13663 result = (wxJPEGHandler *)new wxJPEGHandler();
13664
13665 wxPyEndAllowThreads(__tstate);
13666 if (PyErr_Occurred()) SWIG_fail;
13667 }
13668 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
13669 return resultobj;
13670 fail:
13671 return NULL;
13672 }
13673
13674
13675 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
13676 PyObject *obj;
13677 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13678 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
13679 Py_INCREF(obj);
13680 return Py_BuildValue((char *)"");
13681 }
13682 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13683 PyObject *resultobj;
13684 wxPNMHandler *result;
13685 char *kwnames[] = {
13686 NULL
13687 };
13688
13689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
13690 {
13691 PyThreadState* __tstate = wxPyBeginAllowThreads();
13692 result = (wxPNMHandler *)new wxPNMHandler();
13693
13694 wxPyEndAllowThreads(__tstate);
13695 if (PyErr_Occurred()) SWIG_fail;
13696 }
13697 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
13698 return resultobj;
13699 fail:
13700 return NULL;
13701 }
13702
13703
13704 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
13705 PyObject *obj;
13706 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13707 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
13708 Py_INCREF(obj);
13709 return Py_BuildValue((char *)"");
13710 }
13711 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13712 PyObject *resultobj;
13713 wxXPMHandler *result;
13714 char *kwnames[] = {
13715 NULL
13716 };
13717
13718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
13719 {
13720 PyThreadState* __tstate = wxPyBeginAllowThreads();
13721 result = (wxXPMHandler *)new wxXPMHandler();
13722
13723 wxPyEndAllowThreads(__tstate);
13724 if (PyErr_Occurred()) SWIG_fail;
13725 }
13726 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
13727 return resultobj;
13728 fail:
13729 return NULL;
13730 }
13731
13732
13733 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
13734 PyObject *obj;
13735 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13736 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
13737 Py_INCREF(obj);
13738 return Py_BuildValue((char *)"");
13739 }
13740 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13741 PyObject *resultobj;
13742 wxTIFFHandler *result;
13743 char *kwnames[] = {
13744 NULL
13745 };
13746
13747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
13748 {
13749 PyThreadState* __tstate = wxPyBeginAllowThreads();
13750 result = (wxTIFFHandler *)new wxTIFFHandler();
13751
13752 wxPyEndAllowThreads(__tstate);
13753 if (PyErr_Occurred()) SWIG_fail;
13754 }
13755 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
13756 return resultobj;
13757 fail:
13758 return NULL;
13759 }
13760
13761
13762 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
13763 PyObject *obj;
13764 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13765 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
13766 Py_INCREF(obj);
13767 return Py_BuildValue((char *)"");
13768 }
13769 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
13770 PyObject *resultobj;
13771 wxImage *arg1 = 0 ;
13772 wxImage *arg2 = 0 ;
13773 int arg3 = (int) 236 ;
13774 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
13775 bool result;
13776 PyObject * obj0 = 0 ;
13777 PyObject * obj1 = 0 ;
13778 PyObject * obj2 = 0 ;
13779 PyObject * obj3 = 0 ;
13780 char *kwnames[] = {
13781 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
13782 };
13783
13784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13785 {
13786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13787 if (SWIG_arg_fail(1)) SWIG_fail;
13788 if (arg1 == NULL) {
13789 SWIG_null_ref("wxImage");
13790 }
13791 if (SWIG_arg_fail(1)) SWIG_fail;
13792 }
13793 {
13794 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13795 if (SWIG_arg_fail(2)) SWIG_fail;
13796 if (arg2 == NULL) {
13797 SWIG_null_ref("wxImage");
13798 }
13799 if (SWIG_arg_fail(2)) SWIG_fail;
13800 }
13801 if (obj2) {
13802 {
13803 arg3 = (int)(SWIG_As_int(obj2));
13804 if (SWIG_arg_fail(3)) SWIG_fail;
13805 }
13806 }
13807 if (obj3) {
13808 {
13809 arg4 = (int)(SWIG_As_int(obj3));
13810 if (SWIG_arg_fail(4)) SWIG_fail;
13811 }
13812 }
13813 {
13814 PyThreadState* __tstate = wxPyBeginAllowThreads();
13815 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
13816
13817 wxPyEndAllowThreads(__tstate);
13818 if (PyErr_Occurred()) SWIG_fail;
13819 }
13820 {
13821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13822 }
13823 return resultobj;
13824 fail:
13825 return NULL;
13826 }
13827
13828
13829 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
13830 PyObject *obj;
13831 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13832 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
13833 Py_INCREF(obj);
13834 return Py_BuildValue((char *)"");
13835 }
13836 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13837 PyObject *resultobj;
13838 wxEvtHandler *result;
13839 char *kwnames[] = {
13840 NULL
13841 };
13842
13843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
13844 {
13845 PyThreadState* __tstate = wxPyBeginAllowThreads();
13846 result = (wxEvtHandler *)new wxEvtHandler();
13847
13848 wxPyEndAllowThreads(__tstate);
13849 if (PyErr_Occurred()) SWIG_fail;
13850 }
13851 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
13852 return resultobj;
13853 fail:
13854 return NULL;
13855 }
13856
13857
13858 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13859 PyObject *resultobj;
13860 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13861 wxEvtHandler *result;
13862 PyObject * obj0 = 0 ;
13863 char *kwnames[] = {
13864 (char *) "self", NULL
13865 };
13866
13867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
13868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13869 if (SWIG_arg_fail(1)) SWIG_fail;
13870 {
13871 PyThreadState* __tstate = wxPyBeginAllowThreads();
13872 result = (wxEvtHandler *)(arg1)->GetNextHandler();
13873
13874 wxPyEndAllowThreads(__tstate);
13875 if (PyErr_Occurred()) SWIG_fail;
13876 }
13877 {
13878 resultobj = wxPyMake_wxObject(result, 0);
13879 }
13880 return resultobj;
13881 fail:
13882 return NULL;
13883 }
13884
13885
13886 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13887 PyObject *resultobj;
13888 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13889 wxEvtHandler *result;
13890 PyObject * obj0 = 0 ;
13891 char *kwnames[] = {
13892 (char *) "self", NULL
13893 };
13894
13895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
13896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13897 if (SWIG_arg_fail(1)) SWIG_fail;
13898 {
13899 PyThreadState* __tstate = wxPyBeginAllowThreads();
13900 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
13901
13902 wxPyEndAllowThreads(__tstate);
13903 if (PyErr_Occurred()) SWIG_fail;
13904 }
13905 {
13906 resultobj = wxPyMake_wxObject(result, 0);
13907 }
13908 return resultobj;
13909 fail:
13910 return NULL;
13911 }
13912
13913
13914 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13915 PyObject *resultobj;
13916 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13917 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
13918 PyObject * obj0 = 0 ;
13919 PyObject * obj1 = 0 ;
13920 char *kwnames[] = {
13921 (char *) "self",(char *) "handler", NULL
13922 };
13923
13924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
13925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13926 if (SWIG_arg_fail(1)) SWIG_fail;
13927 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13928 if (SWIG_arg_fail(2)) SWIG_fail;
13929 {
13930 PyThreadState* __tstate = wxPyBeginAllowThreads();
13931 (arg1)->SetNextHandler(arg2);
13932
13933 wxPyEndAllowThreads(__tstate);
13934 if (PyErr_Occurred()) SWIG_fail;
13935 }
13936 Py_INCREF(Py_None); resultobj = Py_None;
13937 return resultobj;
13938 fail:
13939 return NULL;
13940 }
13941
13942
13943 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13944 PyObject *resultobj;
13945 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13946 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
13947 PyObject * obj0 = 0 ;
13948 PyObject * obj1 = 0 ;
13949 char *kwnames[] = {
13950 (char *) "self",(char *) "handler", NULL
13951 };
13952
13953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
13954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13955 if (SWIG_arg_fail(1)) SWIG_fail;
13956 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13957 if (SWIG_arg_fail(2)) SWIG_fail;
13958 {
13959 PyThreadState* __tstate = wxPyBeginAllowThreads();
13960 (arg1)->SetPreviousHandler(arg2);
13961
13962 wxPyEndAllowThreads(__tstate);
13963 if (PyErr_Occurred()) SWIG_fail;
13964 }
13965 Py_INCREF(Py_None); resultobj = Py_None;
13966 return resultobj;
13967 fail:
13968 return NULL;
13969 }
13970
13971
13972 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
13973 PyObject *resultobj;
13974 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13975 bool result;
13976 PyObject * obj0 = 0 ;
13977 char *kwnames[] = {
13978 (char *) "self", NULL
13979 };
13980
13981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
13982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13983 if (SWIG_arg_fail(1)) SWIG_fail;
13984 {
13985 PyThreadState* __tstate = wxPyBeginAllowThreads();
13986 result = (bool)(arg1)->GetEvtHandlerEnabled();
13987
13988 wxPyEndAllowThreads(__tstate);
13989 if (PyErr_Occurred()) SWIG_fail;
13990 }
13991 {
13992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13993 }
13994 return resultobj;
13995 fail:
13996 return NULL;
13997 }
13998
13999
14000 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14001 PyObject *resultobj;
14002 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14003 bool arg2 ;
14004 PyObject * obj0 = 0 ;
14005 PyObject * obj1 = 0 ;
14006 char *kwnames[] = {
14007 (char *) "self",(char *) "enabled", NULL
14008 };
14009
14010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14012 if (SWIG_arg_fail(1)) SWIG_fail;
14013 {
14014 arg2 = (bool)(SWIG_As_bool(obj1));
14015 if (SWIG_arg_fail(2)) SWIG_fail;
14016 }
14017 {
14018 PyThreadState* __tstate = wxPyBeginAllowThreads();
14019 (arg1)->SetEvtHandlerEnabled(arg2);
14020
14021 wxPyEndAllowThreads(__tstate);
14022 if (PyErr_Occurred()) SWIG_fail;
14023 }
14024 Py_INCREF(Py_None); resultobj = Py_None;
14025 return resultobj;
14026 fail:
14027 return NULL;
14028 }
14029
14030
14031 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14032 PyObject *resultobj;
14033 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14034 wxEvent *arg2 = 0 ;
14035 bool result;
14036 PyObject * obj0 = 0 ;
14037 PyObject * obj1 = 0 ;
14038 char *kwnames[] = {
14039 (char *) "self",(char *) "event", NULL
14040 };
14041
14042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14044 if (SWIG_arg_fail(1)) SWIG_fail;
14045 {
14046 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14047 if (SWIG_arg_fail(2)) SWIG_fail;
14048 if (arg2 == NULL) {
14049 SWIG_null_ref("wxEvent");
14050 }
14051 if (SWIG_arg_fail(2)) SWIG_fail;
14052 }
14053 {
14054 PyThreadState* __tstate = wxPyBeginAllowThreads();
14055 result = (bool)(arg1)->ProcessEvent(*arg2);
14056
14057 wxPyEndAllowThreads(__tstate);
14058 if (PyErr_Occurred()) SWIG_fail;
14059 }
14060 {
14061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14062 }
14063 return resultobj;
14064 fail:
14065 return NULL;
14066 }
14067
14068
14069 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14070 PyObject *resultobj;
14071 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14072 wxEvent *arg2 = 0 ;
14073 PyObject * obj0 = 0 ;
14074 PyObject * obj1 = 0 ;
14075 char *kwnames[] = {
14076 (char *) "self",(char *) "event", NULL
14077 };
14078
14079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14081 if (SWIG_arg_fail(1)) SWIG_fail;
14082 {
14083 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14084 if (SWIG_arg_fail(2)) SWIG_fail;
14085 if (arg2 == NULL) {
14086 SWIG_null_ref("wxEvent");
14087 }
14088 if (SWIG_arg_fail(2)) SWIG_fail;
14089 }
14090 {
14091 PyThreadState* __tstate = wxPyBeginAllowThreads();
14092 (arg1)->AddPendingEvent(*arg2);
14093
14094 wxPyEndAllowThreads(__tstate);
14095 if (PyErr_Occurred()) SWIG_fail;
14096 }
14097 Py_INCREF(Py_None); resultobj = Py_None;
14098 return resultobj;
14099 fail:
14100 return NULL;
14101 }
14102
14103
14104 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14105 PyObject *resultobj;
14106 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14107 PyObject * obj0 = 0 ;
14108 char *kwnames[] = {
14109 (char *) "self", NULL
14110 };
14111
14112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14114 if (SWIG_arg_fail(1)) SWIG_fail;
14115 {
14116 PyThreadState* __tstate = wxPyBeginAllowThreads();
14117 (arg1)->ProcessPendingEvents();
14118
14119 wxPyEndAllowThreads(__tstate);
14120 if (PyErr_Occurred()) SWIG_fail;
14121 }
14122 Py_INCREF(Py_None); resultobj = Py_None;
14123 return resultobj;
14124 fail:
14125 return NULL;
14126 }
14127
14128
14129 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14130 PyObject *resultobj;
14131 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14132 int arg2 ;
14133 int arg3 ;
14134 int arg4 ;
14135 PyObject *arg5 = (PyObject *) 0 ;
14136 PyObject * obj0 = 0 ;
14137 PyObject * obj1 = 0 ;
14138 PyObject * obj2 = 0 ;
14139 PyObject * obj3 = 0 ;
14140 PyObject * obj4 = 0 ;
14141 char *kwnames[] = {
14142 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14143 };
14144
14145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14147 if (SWIG_arg_fail(1)) SWIG_fail;
14148 {
14149 arg2 = (int)(SWIG_As_int(obj1));
14150 if (SWIG_arg_fail(2)) SWIG_fail;
14151 }
14152 {
14153 arg3 = (int)(SWIG_As_int(obj2));
14154 if (SWIG_arg_fail(3)) SWIG_fail;
14155 }
14156 {
14157 arg4 = (int)(SWIG_As_int(obj3));
14158 if (SWIG_arg_fail(4)) SWIG_fail;
14159 }
14160 arg5 = obj4;
14161 {
14162 PyThreadState* __tstate = wxPyBeginAllowThreads();
14163 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14164
14165 wxPyEndAllowThreads(__tstate);
14166 if (PyErr_Occurred()) SWIG_fail;
14167 }
14168 Py_INCREF(Py_None); resultobj = Py_None;
14169 return resultobj;
14170 fail:
14171 return NULL;
14172 }
14173
14174
14175 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14176 PyObject *resultobj;
14177 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14178 int arg2 ;
14179 int arg3 = (int) -1 ;
14180 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14181 bool result;
14182 PyObject * obj0 = 0 ;
14183 PyObject * obj1 = 0 ;
14184 PyObject * obj2 = 0 ;
14185 PyObject * obj3 = 0 ;
14186 char *kwnames[] = {
14187 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14188 };
14189
14190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14192 if (SWIG_arg_fail(1)) SWIG_fail;
14193 {
14194 arg2 = (int)(SWIG_As_int(obj1));
14195 if (SWIG_arg_fail(2)) SWIG_fail;
14196 }
14197 if (obj2) {
14198 {
14199 arg3 = (int)(SWIG_As_int(obj2));
14200 if (SWIG_arg_fail(3)) SWIG_fail;
14201 }
14202 }
14203 if (obj3) {
14204 {
14205 arg4 = (wxEventType)(SWIG_As_int(obj3));
14206 if (SWIG_arg_fail(4)) SWIG_fail;
14207 }
14208 }
14209 {
14210 PyThreadState* __tstate = wxPyBeginAllowThreads();
14211 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14212
14213 wxPyEndAllowThreads(__tstate);
14214 if (PyErr_Occurred()) SWIG_fail;
14215 }
14216 {
14217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14218 }
14219 return resultobj;
14220 fail:
14221 return NULL;
14222 }
14223
14224
14225 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14226 PyObject *resultobj;
14227 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14228 PyObject *arg2 = (PyObject *) 0 ;
14229 bool arg3 = (bool) true ;
14230 PyObject * obj0 = 0 ;
14231 PyObject * obj1 = 0 ;
14232 PyObject * obj2 = 0 ;
14233 char *kwnames[] = {
14234 (char *) "self",(char *) "_self",(char *) "incref", NULL
14235 };
14236
14237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14239 if (SWIG_arg_fail(1)) SWIG_fail;
14240 arg2 = obj1;
14241 if (obj2) {
14242 {
14243 arg3 = (bool)(SWIG_As_bool(obj2));
14244 if (SWIG_arg_fail(3)) SWIG_fail;
14245 }
14246 }
14247 {
14248 PyThreadState* __tstate = wxPyBeginAllowThreads();
14249 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14250
14251 wxPyEndAllowThreads(__tstate);
14252 if (PyErr_Occurred()) SWIG_fail;
14253 }
14254 Py_INCREF(Py_None); resultobj = Py_None;
14255 return resultobj;
14256 fail:
14257 return NULL;
14258 }
14259
14260
14261 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14262 PyObject *obj;
14263 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14264 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14265 Py_INCREF(obj);
14266 return Py_BuildValue((char *)"");
14267 }
14268 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14269 PyObject *resultobj;
14270 wxEventType result;
14271 char *kwnames[] = {
14272 NULL
14273 };
14274
14275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14276 {
14277 PyThreadState* __tstate = wxPyBeginAllowThreads();
14278 result = (wxEventType)wxNewEventType();
14279
14280 wxPyEndAllowThreads(__tstate);
14281 if (PyErr_Occurred()) SWIG_fail;
14282 }
14283 {
14284 resultobj = SWIG_From_int((int)(result));
14285 }
14286 return resultobj;
14287 fail:
14288 return NULL;
14289 }
14290
14291
14292 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14293 PyObject *resultobj;
14294 wxEvent *arg1 = (wxEvent *) 0 ;
14295 PyObject * obj0 = 0 ;
14296 char *kwnames[] = {
14297 (char *) "self", NULL
14298 };
14299
14300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14302 if (SWIG_arg_fail(1)) SWIG_fail;
14303 {
14304 PyThreadState* __tstate = wxPyBeginAllowThreads();
14305 delete arg1;
14306
14307 wxPyEndAllowThreads(__tstate);
14308 if (PyErr_Occurred()) SWIG_fail;
14309 }
14310 Py_INCREF(Py_None); resultobj = Py_None;
14311 return resultobj;
14312 fail:
14313 return NULL;
14314 }
14315
14316
14317 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14318 PyObject *resultobj;
14319 wxEvent *arg1 = (wxEvent *) 0 ;
14320 wxEventType arg2 ;
14321 PyObject * obj0 = 0 ;
14322 PyObject * obj1 = 0 ;
14323 char *kwnames[] = {
14324 (char *) "self",(char *) "typ", NULL
14325 };
14326
14327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14329 if (SWIG_arg_fail(1)) SWIG_fail;
14330 {
14331 arg2 = (wxEventType)(SWIG_As_int(obj1));
14332 if (SWIG_arg_fail(2)) SWIG_fail;
14333 }
14334 {
14335 PyThreadState* __tstate = wxPyBeginAllowThreads();
14336 (arg1)->SetEventType(arg2);
14337
14338 wxPyEndAllowThreads(__tstate);
14339 if (PyErr_Occurred()) SWIG_fail;
14340 }
14341 Py_INCREF(Py_None); resultobj = Py_None;
14342 return resultobj;
14343 fail:
14344 return NULL;
14345 }
14346
14347
14348 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14349 PyObject *resultobj;
14350 wxEvent *arg1 = (wxEvent *) 0 ;
14351 wxEventType result;
14352 PyObject * obj0 = 0 ;
14353 char *kwnames[] = {
14354 (char *) "self", NULL
14355 };
14356
14357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14359 if (SWIG_arg_fail(1)) SWIG_fail;
14360 {
14361 PyThreadState* __tstate = wxPyBeginAllowThreads();
14362 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14363
14364 wxPyEndAllowThreads(__tstate);
14365 if (PyErr_Occurred()) SWIG_fail;
14366 }
14367 {
14368 resultobj = SWIG_From_int((int)(result));
14369 }
14370 return resultobj;
14371 fail:
14372 return NULL;
14373 }
14374
14375
14376 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14377 PyObject *resultobj;
14378 wxEvent *arg1 = (wxEvent *) 0 ;
14379 wxObject *result;
14380 PyObject * obj0 = 0 ;
14381 char *kwnames[] = {
14382 (char *) "self", NULL
14383 };
14384
14385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14387 if (SWIG_arg_fail(1)) SWIG_fail;
14388 {
14389 PyThreadState* __tstate = wxPyBeginAllowThreads();
14390 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14391
14392 wxPyEndAllowThreads(__tstate);
14393 if (PyErr_Occurred()) SWIG_fail;
14394 }
14395 {
14396 resultobj = wxPyMake_wxObject(result, 0);
14397 }
14398 return resultobj;
14399 fail:
14400 return NULL;
14401 }
14402
14403
14404 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14405 PyObject *resultobj;
14406 wxEvent *arg1 = (wxEvent *) 0 ;
14407 wxObject *arg2 = (wxObject *) 0 ;
14408 PyObject * obj0 = 0 ;
14409 PyObject * obj1 = 0 ;
14410 char *kwnames[] = {
14411 (char *) "self",(char *) "obj", NULL
14412 };
14413
14414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14416 if (SWIG_arg_fail(1)) SWIG_fail;
14417 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14418 if (SWIG_arg_fail(2)) SWIG_fail;
14419 {
14420 PyThreadState* __tstate = wxPyBeginAllowThreads();
14421 (arg1)->SetEventObject(arg2);
14422
14423 wxPyEndAllowThreads(__tstate);
14424 if (PyErr_Occurred()) SWIG_fail;
14425 }
14426 Py_INCREF(Py_None); resultobj = Py_None;
14427 return resultobj;
14428 fail:
14429 return NULL;
14430 }
14431
14432
14433 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14434 PyObject *resultobj;
14435 wxEvent *arg1 = (wxEvent *) 0 ;
14436 long result;
14437 PyObject * obj0 = 0 ;
14438 char *kwnames[] = {
14439 (char *) "self", NULL
14440 };
14441
14442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14444 if (SWIG_arg_fail(1)) SWIG_fail;
14445 {
14446 PyThreadState* __tstate = wxPyBeginAllowThreads();
14447 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14448
14449 wxPyEndAllowThreads(__tstate);
14450 if (PyErr_Occurred()) SWIG_fail;
14451 }
14452 {
14453 resultobj = SWIG_From_long((long)(result));
14454 }
14455 return resultobj;
14456 fail:
14457 return NULL;
14458 }
14459
14460
14461 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14462 PyObject *resultobj;
14463 wxEvent *arg1 = (wxEvent *) 0 ;
14464 long arg2 = (long) 0 ;
14465 PyObject * obj0 = 0 ;
14466 PyObject * obj1 = 0 ;
14467 char *kwnames[] = {
14468 (char *) "self",(char *) "ts", NULL
14469 };
14470
14471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14473 if (SWIG_arg_fail(1)) SWIG_fail;
14474 if (obj1) {
14475 {
14476 arg2 = (long)(SWIG_As_long(obj1));
14477 if (SWIG_arg_fail(2)) SWIG_fail;
14478 }
14479 }
14480 {
14481 PyThreadState* __tstate = wxPyBeginAllowThreads();
14482 (arg1)->SetTimestamp(arg2);
14483
14484 wxPyEndAllowThreads(__tstate);
14485 if (PyErr_Occurred()) SWIG_fail;
14486 }
14487 Py_INCREF(Py_None); resultobj = Py_None;
14488 return resultobj;
14489 fail:
14490 return NULL;
14491 }
14492
14493
14494 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14495 PyObject *resultobj;
14496 wxEvent *arg1 = (wxEvent *) 0 ;
14497 int result;
14498 PyObject * obj0 = 0 ;
14499 char *kwnames[] = {
14500 (char *) "self", NULL
14501 };
14502
14503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14505 if (SWIG_arg_fail(1)) SWIG_fail;
14506 {
14507 PyThreadState* __tstate = wxPyBeginAllowThreads();
14508 result = (int)((wxEvent const *)arg1)->GetId();
14509
14510 wxPyEndAllowThreads(__tstate);
14511 if (PyErr_Occurred()) SWIG_fail;
14512 }
14513 {
14514 resultobj = SWIG_From_int((int)(result));
14515 }
14516 return resultobj;
14517 fail:
14518 return NULL;
14519 }
14520
14521
14522 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14523 PyObject *resultobj;
14524 wxEvent *arg1 = (wxEvent *) 0 ;
14525 int arg2 ;
14526 PyObject * obj0 = 0 ;
14527 PyObject * obj1 = 0 ;
14528 char *kwnames[] = {
14529 (char *) "self",(char *) "Id", NULL
14530 };
14531
14532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
14533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14534 if (SWIG_arg_fail(1)) SWIG_fail;
14535 {
14536 arg2 = (int)(SWIG_As_int(obj1));
14537 if (SWIG_arg_fail(2)) SWIG_fail;
14538 }
14539 {
14540 PyThreadState* __tstate = wxPyBeginAllowThreads();
14541 (arg1)->SetId(arg2);
14542
14543 wxPyEndAllowThreads(__tstate);
14544 if (PyErr_Occurred()) SWIG_fail;
14545 }
14546 Py_INCREF(Py_None); resultobj = Py_None;
14547 return resultobj;
14548 fail:
14549 return NULL;
14550 }
14551
14552
14553 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14554 PyObject *resultobj;
14555 wxEvent *arg1 = (wxEvent *) 0 ;
14556 bool result;
14557 PyObject * obj0 = 0 ;
14558 char *kwnames[] = {
14559 (char *) "self", NULL
14560 };
14561
14562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
14563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14564 if (SWIG_arg_fail(1)) SWIG_fail;
14565 {
14566 PyThreadState* __tstate = wxPyBeginAllowThreads();
14567 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
14568
14569 wxPyEndAllowThreads(__tstate);
14570 if (PyErr_Occurred()) SWIG_fail;
14571 }
14572 {
14573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14574 }
14575 return resultobj;
14576 fail:
14577 return NULL;
14578 }
14579
14580
14581 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
14582 PyObject *resultobj;
14583 wxEvent *arg1 = (wxEvent *) 0 ;
14584 bool arg2 = (bool) true ;
14585 PyObject * obj0 = 0 ;
14586 PyObject * obj1 = 0 ;
14587 char *kwnames[] = {
14588 (char *) "self",(char *) "skip", NULL
14589 };
14590
14591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
14592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14593 if (SWIG_arg_fail(1)) SWIG_fail;
14594 if (obj1) {
14595 {
14596 arg2 = (bool)(SWIG_As_bool(obj1));
14597 if (SWIG_arg_fail(2)) SWIG_fail;
14598 }
14599 }
14600 {
14601 PyThreadState* __tstate = wxPyBeginAllowThreads();
14602 (arg1)->Skip(arg2);
14603
14604 wxPyEndAllowThreads(__tstate);
14605 if (PyErr_Occurred()) SWIG_fail;
14606 }
14607 Py_INCREF(Py_None); resultobj = Py_None;
14608 return resultobj;
14609 fail:
14610 return NULL;
14611 }
14612
14613
14614 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
14615 PyObject *resultobj;
14616 wxEvent *arg1 = (wxEvent *) 0 ;
14617 bool result;
14618 PyObject * obj0 = 0 ;
14619 char *kwnames[] = {
14620 (char *) "self", NULL
14621 };
14622
14623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
14624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14625 if (SWIG_arg_fail(1)) SWIG_fail;
14626 {
14627 PyThreadState* __tstate = wxPyBeginAllowThreads();
14628 result = (bool)((wxEvent const *)arg1)->GetSkipped();
14629
14630 wxPyEndAllowThreads(__tstate);
14631 if (PyErr_Occurred()) SWIG_fail;
14632 }
14633 {
14634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14635 }
14636 return resultobj;
14637 fail:
14638 return NULL;
14639 }
14640
14641
14642 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
14643 PyObject *resultobj;
14644 wxEvent *arg1 = (wxEvent *) 0 ;
14645 bool result;
14646 PyObject * obj0 = 0 ;
14647 char *kwnames[] = {
14648 (char *) "self", NULL
14649 };
14650
14651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
14652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14653 if (SWIG_arg_fail(1)) SWIG_fail;
14654 {
14655 PyThreadState* __tstate = wxPyBeginAllowThreads();
14656 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
14657
14658 wxPyEndAllowThreads(__tstate);
14659 if (PyErr_Occurred()) SWIG_fail;
14660 }
14661 {
14662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14663 }
14664 return resultobj;
14665 fail:
14666 return NULL;
14667 }
14668
14669
14670 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14671 PyObject *resultobj;
14672 wxEvent *arg1 = (wxEvent *) 0 ;
14673 int result;
14674 PyObject * obj0 = 0 ;
14675 char *kwnames[] = {
14676 (char *) "self", NULL
14677 };
14678
14679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
14680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14681 if (SWIG_arg_fail(1)) SWIG_fail;
14682 {
14683 PyThreadState* __tstate = wxPyBeginAllowThreads();
14684 result = (int)(arg1)->StopPropagation();
14685
14686 wxPyEndAllowThreads(__tstate);
14687 if (PyErr_Occurred()) SWIG_fail;
14688 }
14689 {
14690 resultobj = SWIG_From_int((int)(result));
14691 }
14692 return resultobj;
14693 fail:
14694 return NULL;
14695 }
14696
14697
14698 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14699 PyObject *resultobj;
14700 wxEvent *arg1 = (wxEvent *) 0 ;
14701 int arg2 ;
14702 PyObject * obj0 = 0 ;
14703 PyObject * obj1 = 0 ;
14704 char *kwnames[] = {
14705 (char *) "self",(char *) "propagationLevel", NULL
14706 };
14707
14708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
14709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14710 if (SWIG_arg_fail(1)) SWIG_fail;
14711 {
14712 arg2 = (int)(SWIG_As_int(obj1));
14713 if (SWIG_arg_fail(2)) SWIG_fail;
14714 }
14715 {
14716 PyThreadState* __tstate = wxPyBeginAllowThreads();
14717 (arg1)->ResumePropagation(arg2);
14718
14719 wxPyEndAllowThreads(__tstate);
14720 if (PyErr_Occurred()) SWIG_fail;
14721 }
14722 Py_INCREF(Py_None); resultobj = Py_None;
14723 return resultobj;
14724 fail:
14725 return NULL;
14726 }
14727
14728
14729 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
14730 PyObject *resultobj;
14731 wxEvent *arg1 = (wxEvent *) 0 ;
14732 wxEvent *result;
14733 PyObject * obj0 = 0 ;
14734 char *kwnames[] = {
14735 (char *) "self", NULL
14736 };
14737
14738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
14739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14740 if (SWIG_arg_fail(1)) SWIG_fail;
14741 {
14742 PyThreadState* __tstate = wxPyBeginAllowThreads();
14743 result = (wxEvent *)(arg1)->Clone();
14744
14745 wxPyEndAllowThreads(__tstate);
14746 if (PyErr_Occurred()) SWIG_fail;
14747 }
14748 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
14749 return resultobj;
14750 fail:
14751 return NULL;
14752 }
14753
14754
14755 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
14756 PyObject *obj;
14757 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14758 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
14759 Py_INCREF(obj);
14760 return Py_BuildValue((char *)"");
14761 }
14762 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14763 PyObject *resultobj;
14764 wxEvent *arg1 = 0 ;
14765 wxPropagationDisabler *result;
14766 PyObject * obj0 = 0 ;
14767 char *kwnames[] = {
14768 (char *) "event", NULL
14769 };
14770
14771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
14772 {
14773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14774 if (SWIG_arg_fail(1)) SWIG_fail;
14775 if (arg1 == NULL) {
14776 SWIG_null_ref("wxEvent");
14777 }
14778 if (SWIG_arg_fail(1)) SWIG_fail;
14779 }
14780 {
14781 PyThreadState* __tstate = wxPyBeginAllowThreads();
14782 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
14783
14784 wxPyEndAllowThreads(__tstate);
14785 if (PyErr_Occurred()) SWIG_fail;
14786 }
14787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
14788 return resultobj;
14789 fail:
14790 return NULL;
14791 }
14792
14793
14794 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14795 PyObject *resultobj;
14796 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
14797 PyObject * obj0 = 0 ;
14798 char *kwnames[] = {
14799 (char *) "self", NULL
14800 };
14801
14802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
14803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
14804 if (SWIG_arg_fail(1)) SWIG_fail;
14805 {
14806 PyThreadState* __tstate = wxPyBeginAllowThreads();
14807 delete arg1;
14808
14809 wxPyEndAllowThreads(__tstate);
14810 if (PyErr_Occurred()) SWIG_fail;
14811 }
14812 Py_INCREF(Py_None); resultobj = Py_None;
14813 return resultobj;
14814 fail:
14815 return NULL;
14816 }
14817
14818
14819 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
14820 PyObject *obj;
14821 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14822 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
14823 Py_INCREF(obj);
14824 return Py_BuildValue((char *)"");
14825 }
14826 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
14827 PyObject *resultobj;
14828 wxEvent *arg1 = 0 ;
14829 wxPropagateOnce *result;
14830 PyObject * obj0 = 0 ;
14831 char *kwnames[] = {
14832 (char *) "event", NULL
14833 };
14834
14835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
14836 {
14837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14838 if (SWIG_arg_fail(1)) SWIG_fail;
14839 if (arg1 == NULL) {
14840 SWIG_null_ref("wxEvent");
14841 }
14842 if (SWIG_arg_fail(1)) SWIG_fail;
14843 }
14844 {
14845 PyThreadState* __tstate = wxPyBeginAllowThreads();
14846 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
14847
14848 wxPyEndAllowThreads(__tstate);
14849 if (PyErr_Occurred()) SWIG_fail;
14850 }
14851 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
14852 return resultobj;
14853 fail:
14854 return NULL;
14855 }
14856
14857
14858 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
14859 PyObject *resultobj;
14860 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
14861 PyObject * obj0 = 0 ;
14862 char *kwnames[] = {
14863 (char *) "self", NULL
14864 };
14865
14866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
14867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
14868 if (SWIG_arg_fail(1)) SWIG_fail;
14869 {
14870 PyThreadState* __tstate = wxPyBeginAllowThreads();
14871 delete arg1;
14872
14873 wxPyEndAllowThreads(__tstate);
14874 if (PyErr_Occurred()) SWIG_fail;
14875 }
14876 Py_INCREF(Py_None); resultobj = Py_None;
14877 return resultobj;
14878 fail:
14879 return NULL;
14880 }
14881
14882
14883 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
14884 PyObject *obj;
14885 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14886 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
14887 Py_INCREF(obj);
14888 return Py_BuildValue((char *)"");
14889 }
14890 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14891 PyObject *resultobj;
14892 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
14893 int arg2 = (int) 0 ;
14894 wxCommandEvent *result;
14895 PyObject * obj0 = 0 ;
14896 PyObject * obj1 = 0 ;
14897 char *kwnames[] = {
14898 (char *) "commandType",(char *) "winid", NULL
14899 };
14900
14901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
14902 if (obj0) {
14903 {
14904 arg1 = (wxEventType)(SWIG_As_int(obj0));
14905 if (SWIG_arg_fail(1)) SWIG_fail;
14906 }
14907 }
14908 if (obj1) {
14909 {
14910 arg2 = (int)(SWIG_As_int(obj1));
14911 if (SWIG_arg_fail(2)) SWIG_fail;
14912 }
14913 }
14914 {
14915 PyThreadState* __tstate = wxPyBeginAllowThreads();
14916 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
14917
14918 wxPyEndAllowThreads(__tstate);
14919 if (PyErr_Occurred()) SWIG_fail;
14920 }
14921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
14922 return resultobj;
14923 fail:
14924 return NULL;
14925 }
14926
14927
14928 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14929 PyObject *resultobj;
14930 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
14931 int result;
14932 PyObject * obj0 = 0 ;
14933 char *kwnames[] = {
14934 (char *) "self", NULL
14935 };
14936
14937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
14938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
14939 if (SWIG_arg_fail(1)) SWIG_fail;
14940 {
14941 PyThreadState* __tstate = wxPyBeginAllowThreads();
14942 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
14943
14944 wxPyEndAllowThreads(__tstate);
14945 if (PyErr_Occurred()) SWIG_fail;
14946 }
14947 {
14948 resultobj = SWIG_From_int((int)(result));
14949 }
14950 return resultobj;
14951 fail:
14952 return NULL;
14953 }
14954
14955
14956 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
14957 PyObject *resultobj;
14958 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
14959 wxString *arg2 = 0 ;
14960 bool temp2 = false ;
14961 PyObject * obj0 = 0 ;
14962 PyObject * obj1 = 0 ;
14963 char *kwnames[] = {
14964 (char *) "self",(char *) "s", NULL
14965 };
14966
14967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
14968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
14969 if (SWIG_arg_fail(1)) SWIG_fail;
14970 {
14971 arg2 = wxString_in_helper(obj1);
14972 if (arg2 == NULL) SWIG_fail;
14973 temp2 = true;
14974 }
14975 {
14976 PyThreadState* __tstate = wxPyBeginAllowThreads();
14977 (arg1)->SetString((wxString const &)*arg2);
14978
14979 wxPyEndAllowThreads(__tstate);
14980 if (PyErr_Occurred()) SWIG_fail;
14981 }
14982 Py_INCREF(Py_None); resultobj = Py_None;
14983 {
14984 if (temp2)
14985 delete arg2;
14986 }
14987 return resultobj;
14988 fail:
14989 {
14990 if (temp2)
14991 delete arg2;
14992 }
14993 return NULL;
14994 }
14995
14996
14997 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
14998 PyObject *resultobj;
14999 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15000 wxString result;
15001 PyObject * obj0 = 0 ;
15002 char *kwnames[] = {
15003 (char *) "self", NULL
15004 };
15005
15006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15008 if (SWIG_arg_fail(1)) SWIG_fail;
15009 {
15010 PyThreadState* __tstate = wxPyBeginAllowThreads();
15011 result = ((wxCommandEvent const *)arg1)->GetString();
15012
15013 wxPyEndAllowThreads(__tstate);
15014 if (PyErr_Occurred()) SWIG_fail;
15015 }
15016 {
15017 #if wxUSE_UNICODE
15018 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15019 #else
15020 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15021 #endif
15022 }
15023 return resultobj;
15024 fail:
15025 return NULL;
15026 }
15027
15028
15029 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15030 PyObject *resultobj;
15031 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15032 bool result;
15033 PyObject * obj0 = 0 ;
15034 char *kwnames[] = {
15035 (char *) "self", NULL
15036 };
15037
15038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15040 if (SWIG_arg_fail(1)) SWIG_fail;
15041 {
15042 PyThreadState* __tstate = wxPyBeginAllowThreads();
15043 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15044
15045 wxPyEndAllowThreads(__tstate);
15046 if (PyErr_Occurred()) SWIG_fail;
15047 }
15048 {
15049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15050 }
15051 return resultobj;
15052 fail:
15053 return NULL;
15054 }
15055
15056
15057 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15058 PyObject *resultobj;
15059 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15060 bool result;
15061 PyObject * obj0 = 0 ;
15062 char *kwnames[] = {
15063 (char *) "self", NULL
15064 };
15065
15066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15068 if (SWIG_arg_fail(1)) SWIG_fail;
15069 {
15070 PyThreadState* __tstate = wxPyBeginAllowThreads();
15071 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15072
15073 wxPyEndAllowThreads(__tstate);
15074 if (PyErr_Occurred()) SWIG_fail;
15075 }
15076 {
15077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15078 }
15079 return resultobj;
15080 fail:
15081 return NULL;
15082 }
15083
15084
15085 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15086 PyObject *resultobj;
15087 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15088 long arg2 ;
15089 PyObject * obj0 = 0 ;
15090 PyObject * obj1 = 0 ;
15091 char *kwnames[] = {
15092 (char *) "self",(char *) "extraLong", NULL
15093 };
15094
15095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15097 if (SWIG_arg_fail(1)) SWIG_fail;
15098 {
15099 arg2 = (long)(SWIG_As_long(obj1));
15100 if (SWIG_arg_fail(2)) SWIG_fail;
15101 }
15102 {
15103 PyThreadState* __tstate = wxPyBeginAllowThreads();
15104 (arg1)->SetExtraLong(arg2);
15105
15106 wxPyEndAllowThreads(__tstate);
15107 if (PyErr_Occurred()) SWIG_fail;
15108 }
15109 Py_INCREF(Py_None); resultobj = Py_None;
15110 return resultobj;
15111 fail:
15112 return NULL;
15113 }
15114
15115
15116 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15117 PyObject *resultobj;
15118 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15119 long result;
15120 PyObject * obj0 = 0 ;
15121 char *kwnames[] = {
15122 (char *) "self", NULL
15123 };
15124
15125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15127 if (SWIG_arg_fail(1)) SWIG_fail;
15128 {
15129 PyThreadState* __tstate = wxPyBeginAllowThreads();
15130 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15131
15132 wxPyEndAllowThreads(__tstate);
15133 if (PyErr_Occurred()) SWIG_fail;
15134 }
15135 {
15136 resultobj = SWIG_From_long((long)(result));
15137 }
15138 return resultobj;
15139 fail:
15140 return NULL;
15141 }
15142
15143
15144 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15145 PyObject *resultobj;
15146 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15147 int arg2 ;
15148 PyObject * obj0 = 0 ;
15149 PyObject * obj1 = 0 ;
15150 char *kwnames[] = {
15151 (char *) "self",(char *) "i", NULL
15152 };
15153
15154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15156 if (SWIG_arg_fail(1)) SWIG_fail;
15157 {
15158 arg2 = (int)(SWIG_As_int(obj1));
15159 if (SWIG_arg_fail(2)) SWIG_fail;
15160 }
15161 {
15162 PyThreadState* __tstate = wxPyBeginAllowThreads();
15163 (arg1)->SetInt(arg2);
15164
15165 wxPyEndAllowThreads(__tstate);
15166 if (PyErr_Occurred()) SWIG_fail;
15167 }
15168 Py_INCREF(Py_None); resultobj = Py_None;
15169 return resultobj;
15170 fail:
15171 return NULL;
15172 }
15173
15174
15175 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15176 PyObject *resultobj;
15177 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15178 long result;
15179 PyObject * obj0 = 0 ;
15180 char *kwnames[] = {
15181 (char *) "self", NULL
15182 };
15183
15184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15186 if (SWIG_arg_fail(1)) SWIG_fail;
15187 {
15188 PyThreadState* __tstate = wxPyBeginAllowThreads();
15189 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15190
15191 wxPyEndAllowThreads(__tstate);
15192 if (PyErr_Occurred()) SWIG_fail;
15193 }
15194 {
15195 resultobj = SWIG_From_long((long)(result));
15196 }
15197 return resultobj;
15198 fail:
15199 return NULL;
15200 }
15201
15202
15203 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15204 PyObject *resultobj;
15205 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15206 wxEvent *result;
15207 PyObject * obj0 = 0 ;
15208 char *kwnames[] = {
15209 (char *) "self", NULL
15210 };
15211
15212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15214 if (SWIG_arg_fail(1)) SWIG_fail;
15215 {
15216 PyThreadState* __tstate = wxPyBeginAllowThreads();
15217 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15218
15219 wxPyEndAllowThreads(__tstate);
15220 if (PyErr_Occurred()) SWIG_fail;
15221 }
15222 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15223 return resultobj;
15224 fail:
15225 return NULL;
15226 }
15227
15228
15229 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15230 PyObject *obj;
15231 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15232 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15233 Py_INCREF(obj);
15234 return Py_BuildValue((char *)"");
15235 }
15236 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15237 PyObject *resultobj;
15238 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15239 int arg2 = (int) 0 ;
15240 wxNotifyEvent *result;
15241 PyObject * obj0 = 0 ;
15242 PyObject * obj1 = 0 ;
15243 char *kwnames[] = {
15244 (char *) "commandType",(char *) "winid", NULL
15245 };
15246
15247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15248 if (obj0) {
15249 {
15250 arg1 = (wxEventType)(SWIG_As_int(obj0));
15251 if (SWIG_arg_fail(1)) SWIG_fail;
15252 }
15253 }
15254 if (obj1) {
15255 {
15256 arg2 = (int)(SWIG_As_int(obj1));
15257 if (SWIG_arg_fail(2)) SWIG_fail;
15258 }
15259 }
15260 {
15261 PyThreadState* __tstate = wxPyBeginAllowThreads();
15262 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15263
15264 wxPyEndAllowThreads(__tstate);
15265 if (PyErr_Occurred()) SWIG_fail;
15266 }
15267 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15268 return resultobj;
15269 fail:
15270 return NULL;
15271 }
15272
15273
15274 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15275 PyObject *resultobj;
15276 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15277 PyObject * obj0 = 0 ;
15278 char *kwnames[] = {
15279 (char *) "self", NULL
15280 };
15281
15282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15284 if (SWIG_arg_fail(1)) SWIG_fail;
15285 {
15286 PyThreadState* __tstate = wxPyBeginAllowThreads();
15287 (arg1)->Veto();
15288
15289 wxPyEndAllowThreads(__tstate);
15290 if (PyErr_Occurred()) SWIG_fail;
15291 }
15292 Py_INCREF(Py_None); resultobj = Py_None;
15293 return resultobj;
15294 fail:
15295 return NULL;
15296 }
15297
15298
15299 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15300 PyObject *resultobj;
15301 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15302 PyObject * obj0 = 0 ;
15303 char *kwnames[] = {
15304 (char *) "self", NULL
15305 };
15306
15307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15309 if (SWIG_arg_fail(1)) SWIG_fail;
15310 {
15311 PyThreadState* __tstate = wxPyBeginAllowThreads();
15312 (arg1)->Allow();
15313
15314 wxPyEndAllowThreads(__tstate);
15315 if (PyErr_Occurred()) SWIG_fail;
15316 }
15317 Py_INCREF(Py_None); resultobj = Py_None;
15318 return resultobj;
15319 fail:
15320 return NULL;
15321 }
15322
15323
15324 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15325 PyObject *resultobj;
15326 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15327 bool result;
15328 PyObject * obj0 = 0 ;
15329 char *kwnames[] = {
15330 (char *) "self", NULL
15331 };
15332
15333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15335 if (SWIG_arg_fail(1)) SWIG_fail;
15336 {
15337 PyThreadState* __tstate = wxPyBeginAllowThreads();
15338 result = (bool)(arg1)->IsAllowed();
15339
15340 wxPyEndAllowThreads(__tstate);
15341 if (PyErr_Occurred()) SWIG_fail;
15342 }
15343 {
15344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15345 }
15346 return resultobj;
15347 fail:
15348 return NULL;
15349 }
15350
15351
15352 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15353 PyObject *obj;
15354 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15355 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15356 Py_INCREF(obj);
15357 return Py_BuildValue((char *)"");
15358 }
15359 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15360 PyObject *resultobj;
15361 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15362 int arg2 = (int) 0 ;
15363 int arg3 = (int) 0 ;
15364 int arg4 = (int) 0 ;
15365 wxScrollEvent *result;
15366 PyObject * obj0 = 0 ;
15367 PyObject * obj1 = 0 ;
15368 PyObject * obj2 = 0 ;
15369 PyObject * obj3 = 0 ;
15370 char *kwnames[] = {
15371 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15372 };
15373
15374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15375 if (obj0) {
15376 {
15377 arg1 = (wxEventType)(SWIG_As_int(obj0));
15378 if (SWIG_arg_fail(1)) SWIG_fail;
15379 }
15380 }
15381 if (obj1) {
15382 {
15383 arg2 = (int)(SWIG_As_int(obj1));
15384 if (SWIG_arg_fail(2)) SWIG_fail;
15385 }
15386 }
15387 if (obj2) {
15388 {
15389 arg3 = (int)(SWIG_As_int(obj2));
15390 if (SWIG_arg_fail(3)) SWIG_fail;
15391 }
15392 }
15393 if (obj3) {
15394 {
15395 arg4 = (int)(SWIG_As_int(obj3));
15396 if (SWIG_arg_fail(4)) SWIG_fail;
15397 }
15398 }
15399 {
15400 PyThreadState* __tstate = wxPyBeginAllowThreads();
15401 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15402
15403 wxPyEndAllowThreads(__tstate);
15404 if (PyErr_Occurred()) SWIG_fail;
15405 }
15406 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15407 return resultobj;
15408 fail:
15409 return NULL;
15410 }
15411
15412
15413 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15414 PyObject *resultobj;
15415 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15416 int result;
15417 PyObject * obj0 = 0 ;
15418 char *kwnames[] = {
15419 (char *) "self", NULL
15420 };
15421
15422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15424 if (SWIG_arg_fail(1)) SWIG_fail;
15425 {
15426 PyThreadState* __tstate = wxPyBeginAllowThreads();
15427 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15428
15429 wxPyEndAllowThreads(__tstate);
15430 if (PyErr_Occurred()) SWIG_fail;
15431 }
15432 {
15433 resultobj = SWIG_From_int((int)(result));
15434 }
15435 return resultobj;
15436 fail:
15437 return NULL;
15438 }
15439
15440
15441 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15442 PyObject *resultobj;
15443 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15444 int result;
15445 PyObject * obj0 = 0 ;
15446 char *kwnames[] = {
15447 (char *) "self", NULL
15448 };
15449
15450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15452 if (SWIG_arg_fail(1)) SWIG_fail;
15453 {
15454 PyThreadState* __tstate = wxPyBeginAllowThreads();
15455 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15456
15457 wxPyEndAllowThreads(__tstate);
15458 if (PyErr_Occurred()) SWIG_fail;
15459 }
15460 {
15461 resultobj = SWIG_From_int((int)(result));
15462 }
15463 return resultobj;
15464 fail:
15465 return NULL;
15466 }
15467
15468
15469 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15470 PyObject *resultobj;
15471 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15472 int arg2 ;
15473 PyObject * obj0 = 0 ;
15474 PyObject * obj1 = 0 ;
15475 char *kwnames[] = {
15476 (char *) "self",(char *) "orient", NULL
15477 };
15478
15479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15481 if (SWIG_arg_fail(1)) SWIG_fail;
15482 {
15483 arg2 = (int)(SWIG_As_int(obj1));
15484 if (SWIG_arg_fail(2)) SWIG_fail;
15485 }
15486 {
15487 PyThreadState* __tstate = wxPyBeginAllowThreads();
15488 (arg1)->SetOrientation(arg2);
15489
15490 wxPyEndAllowThreads(__tstate);
15491 if (PyErr_Occurred()) SWIG_fail;
15492 }
15493 Py_INCREF(Py_None); resultobj = Py_None;
15494 return resultobj;
15495 fail:
15496 return NULL;
15497 }
15498
15499
15500 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15501 PyObject *resultobj;
15502 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15503 int arg2 ;
15504 PyObject * obj0 = 0 ;
15505 PyObject * obj1 = 0 ;
15506 char *kwnames[] = {
15507 (char *) "self",(char *) "pos", NULL
15508 };
15509
15510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15512 if (SWIG_arg_fail(1)) SWIG_fail;
15513 {
15514 arg2 = (int)(SWIG_As_int(obj1));
15515 if (SWIG_arg_fail(2)) SWIG_fail;
15516 }
15517 {
15518 PyThreadState* __tstate = wxPyBeginAllowThreads();
15519 (arg1)->SetPosition(arg2);
15520
15521 wxPyEndAllowThreads(__tstate);
15522 if (PyErr_Occurred()) SWIG_fail;
15523 }
15524 Py_INCREF(Py_None); resultobj = Py_None;
15525 return resultobj;
15526 fail:
15527 return NULL;
15528 }
15529
15530
15531 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
15532 PyObject *obj;
15533 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15534 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
15535 Py_INCREF(obj);
15536 return Py_BuildValue((char *)"");
15537 }
15538 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15539 PyObject *resultobj;
15540 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15541 int arg2 = (int) 0 ;
15542 int arg3 = (int) 0 ;
15543 wxScrollWinEvent *result;
15544 PyObject * obj0 = 0 ;
15545 PyObject * obj1 = 0 ;
15546 PyObject * obj2 = 0 ;
15547 char *kwnames[] = {
15548 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
15549 };
15550
15551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15552 if (obj0) {
15553 {
15554 arg1 = (wxEventType)(SWIG_As_int(obj0));
15555 if (SWIG_arg_fail(1)) SWIG_fail;
15556 }
15557 }
15558 if (obj1) {
15559 {
15560 arg2 = (int)(SWIG_As_int(obj1));
15561 if (SWIG_arg_fail(2)) SWIG_fail;
15562 }
15563 }
15564 if (obj2) {
15565 {
15566 arg3 = (int)(SWIG_As_int(obj2));
15567 if (SWIG_arg_fail(3)) SWIG_fail;
15568 }
15569 }
15570 {
15571 PyThreadState* __tstate = wxPyBeginAllowThreads();
15572 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
15573
15574 wxPyEndAllowThreads(__tstate);
15575 if (PyErr_Occurred()) SWIG_fail;
15576 }
15577 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
15578 return resultobj;
15579 fail:
15580 return NULL;
15581 }
15582
15583
15584 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15585 PyObject *resultobj;
15586 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15587 int result;
15588 PyObject * obj0 = 0 ;
15589 char *kwnames[] = {
15590 (char *) "self", NULL
15591 };
15592
15593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
15594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15595 if (SWIG_arg_fail(1)) SWIG_fail;
15596 {
15597 PyThreadState* __tstate = wxPyBeginAllowThreads();
15598 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
15599
15600 wxPyEndAllowThreads(__tstate);
15601 if (PyErr_Occurred()) SWIG_fail;
15602 }
15603 {
15604 resultobj = SWIG_From_int((int)(result));
15605 }
15606 return resultobj;
15607 fail:
15608 return NULL;
15609 }
15610
15611
15612 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15613 PyObject *resultobj;
15614 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15615 int result;
15616 PyObject * obj0 = 0 ;
15617 char *kwnames[] = {
15618 (char *) "self", NULL
15619 };
15620
15621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
15622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15623 if (SWIG_arg_fail(1)) SWIG_fail;
15624 {
15625 PyThreadState* __tstate = wxPyBeginAllowThreads();
15626 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
15627
15628 wxPyEndAllowThreads(__tstate);
15629 if (PyErr_Occurred()) SWIG_fail;
15630 }
15631 {
15632 resultobj = SWIG_From_int((int)(result));
15633 }
15634 return resultobj;
15635 fail:
15636 return NULL;
15637 }
15638
15639
15640 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15641 PyObject *resultobj;
15642 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15643 int arg2 ;
15644 PyObject * obj0 = 0 ;
15645 PyObject * obj1 = 0 ;
15646 char *kwnames[] = {
15647 (char *) "self",(char *) "orient", NULL
15648 };
15649
15650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15652 if (SWIG_arg_fail(1)) SWIG_fail;
15653 {
15654 arg2 = (int)(SWIG_As_int(obj1));
15655 if (SWIG_arg_fail(2)) SWIG_fail;
15656 }
15657 {
15658 PyThreadState* __tstate = wxPyBeginAllowThreads();
15659 (arg1)->SetOrientation(arg2);
15660
15661 wxPyEndAllowThreads(__tstate);
15662 if (PyErr_Occurred()) SWIG_fail;
15663 }
15664 Py_INCREF(Py_None); resultobj = Py_None;
15665 return resultobj;
15666 fail:
15667 return NULL;
15668 }
15669
15670
15671 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15672 PyObject *resultobj;
15673 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15674 int arg2 ;
15675 PyObject * obj0 = 0 ;
15676 PyObject * obj1 = 0 ;
15677 char *kwnames[] = {
15678 (char *) "self",(char *) "pos", NULL
15679 };
15680
15681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15683 if (SWIG_arg_fail(1)) SWIG_fail;
15684 {
15685 arg2 = (int)(SWIG_As_int(obj1));
15686 if (SWIG_arg_fail(2)) SWIG_fail;
15687 }
15688 {
15689 PyThreadState* __tstate = wxPyBeginAllowThreads();
15690 (arg1)->SetPosition(arg2);
15691
15692 wxPyEndAllowThreads(__tstate);
15693 if (PyErr_Occurred()) SWIG_fail;
15694 }
15695 Py_INCREF(Py_None); resultobj = Py_None;
15696 return resultobj;
15697 fail:
15698 return NULL;
15699 }
15700
15701
15702 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
15703 PyObject *obj;
15704 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15705 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
15706 Py_INCREF(obj);
15707 return Py_BuildValue((char *)"");
15708 }
15709 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15710 PyObject *resultobj;
15711 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15712 wxMouseEvent *result;
15713 PyObject * obj0 = 0 ;
15714 char *kwnames[] = {
15715 (char *) "mouseType", NULL
15716 };
15717
15718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
15719 if (obj0) {
15720 {
15721 arg1 = (wxEventType)(SWIG_As_int(obj0));
15722 if (SWIG_arg_fail(1)) SWIG_fail;
15723 }
15724 }
15725 {
15726 PyThreadState* __tstate = wxPyBeginAllowThreads();
15727 result = (wxMouseEvent *)new wxMouseEvent(arg1);
15728
15729 wxPyEndAllowThreads(__tstate);
15730 if (PyErr_Occurred()) SWIG_fail;
15731 }
15732 {
15733 resultobj = wxPyMake_wxObject(result, 1);
15734 }
15735 return resultobj;
15736 fail:
15737 return NULL;
15738 }
15739
15740
15741 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
15742 PyObject *resultobj;
15743 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15744 bool result;
15745 PyObject * obj0 = 0 ;
15746 char *kwnames[] = {
15747 (char *) "self", NULL
15748 };
15749
15750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
15751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15752 if (SWIG_arg_fail(1)) SWIG_fail;
15753 {
15754 PyThreadState* __tstate = wxPyBeginAllowThreads();
15755 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
15756
15757 wxPyEndAllowThreads(__tstate);
15758 if (PyErr_Occurred()) SWIG_fail;
15759 }
15760 {
15761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15762 }
15763 return resultobj;
15764 fail:
15765 return NULL;
15766 }
15767
15768
15769 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
15770 PyObject *resultobj;
15771 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15772 int arg2 = (int) wxMOUSE_BTN_ANY ;
15773 bool result;
15774 PyObject * obj0 = 0 ;
15775 PyObject * obj1 = 0 ;
15776 char *kwnames[] = {
15777 (char *) "self",(char *) "but", NULL
15778 };
15779
15780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
15781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15782 if (SWIG_arg_fail(1)) SWIG_fail;
15783 if (obj1) {
15784 {
15785 arg2 = (int)(SWIG_As_int(obj1));
15786 if (SWIG_arg_fail(2)) SWIG_fail;
15787 }
15788 }
15789 {
15790 PyThreadState* __tstate = wxPyBeginAllowThreads();
15791 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
15792
15793 wxPyEndAllowThreads(__tstate);
15794 if (PyErr_Occurred()) SWIG_fail;
15795 }
15796 {
15797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15798 }
15799 return resultobj;
15800 fail:
15801 return NULL;
15802 }
15803
15804
15805 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
15806 PyObject *resultobj;
15807 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15808 int arg2 = (int) wxMOUSE_BTN_ANY ;
15809 bool result;
15810 PyObject * obj0 = 0 ;
15811 PyObject * obj1 = 0 ;
15812 char *kwnames[] = {
15813 (char *) "self",(char *) "but", NULL
15814 };
15815
15816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
15817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15818 if (SWIG_arg_fail(1)) SWIG_fail;
15819 if (obj1) {
15820 {
15821 arg2 = (int)(SWIG_As_int(obj1));
15822 if (SWIG_arg_fail(2)) SWIG_fail;
15823 }
15824 }
15825 {
15826 PyThreadState* __tstate = wxPyBeginAllowThreads();
15827 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
15828
15829 wxPyEndAllowThreads(__tstate);
15830 if (PyErr_Occurred()) SWIG_fail;
15831 }
15832 {
15833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15834 }
15835 return resultobj;
15836 fail:
15837 return NULL;
15838 }
15839
15840
15841 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
15842 PyObject *resultobj;
15843 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15844 int arg2 = (int) wxMOUSE_BTN_ANY ;
15845 bool result;
15846 PyObject * obj0 = 0 ;
15847 PyObject * obj1 = 0 ;
15848 char *kwnames[] = {
15849 (char *) "self",(char *) "but", NULL
15850 };
15851
15852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
15853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15854 if (SWIG_arg_fail(1)) SWIG_fail;
15855 if (obj1) {
15856 {
15857 arg2 = (int)(SWIG_As_int(obj1));
15858 if (SWIG_arg_fail(2)) SWIG_fail;
15859 }
15860 }
15861 {
15862 PyThreadState* __tstate = wxPyBeginAllowThreads();
15863 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
15864
15865 wxPyEndAllowThreads(__tstate);
15866 if (PyErr_Occurred()) SWIG_fail;
15867 }
15868 {
15869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15870 }
15871 return resultobj;
15872 fail:
15873 return NULL;
15874 }
15875
15876
15877 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
15878 PyObject *resultobj;
15879 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15880 int arg2 ;
15881 bool result;
15882 PyObject * obj0 = 0 ;
15883 PyObject * obj1 = 0 ;
15884 char *kwnames[] = {
15885 (char *) "self",(char *) "but", NULL
15886 };
15887
15888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
15889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15890 if (SWIG_arg_fail(1)) SWIG_fail;
15891 {
15892 arg2 = (int)(SWIG_As_int(obj1));
15893 if (SWIG_arg_fail(2)) SWIG_fail;
15894 }
15895 {
15896 PyThreadState* __tstate = wxPyBeginAllowThreads();
15897 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
15898
15899 wxPyEndAllowThreads(__tstate);
15900 if (PyErr_Occurred()) SWIG_fail;
15901 }
15902 {
15903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15904 }
15905 return resultobj;
15906 fail:
15907 return NULL;
15908 }
15909
15910
15911 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
15912 PyObject *resultobj;
15913 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15914 int arg2 ;
15915 bool result;
15916 PyObject * obj0 = 0 ;
15917 PyObject * obj1 = 0 ;
15918 char *kwnames[] = {
15919 (char *) "self",(char *) "but", NULL
15920 };
15921
15922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
15923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15924 if (SWIG_arg_fail(1)) SWIG_fail;
15925 {
15926 arg2 = (int)(SWIG_As_int(obj1));
15927 if (SWIG_arg_fail(2)) SWIG_fail;
15928 }
15929 {
15930 PyThreadState* __tstate = wxPyBeginAllowThreads();
15931 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
15932
15933 wxPyEndAllowThreads(__tstate);
15934 if (PyErr_Occurred()) SWIG_fail;
15935 }
15936 {
15937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15938 }
15939 return resultobj;
15940 fail:
15941 return NULL;
15942 }
15943
15944
15945 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
15946 PyObject *resultobj;
15947 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15948 int result;
15949 PyObject * obj0 = 0 ;
15950 char *kwnames[] = {
15951 (char *) "self", NULL
15952 };
15953
15954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
15955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15956 if (SWIG_arg_fail(1)) SWIG_fail;
15957 {
15958 PyThreadState* __tstate = wxPyBeginAllowThreads();
15959 result = (int)((wxMouseEvent const *)arg1)->GetButton();
15960
15961 wxPyEndAllowThreads(__tstate);
15962 if (PyErr_Occurred()) SWIG_fail;
15963 }
15964 {
15965 resultobj = SWIG_From_int((int)(result));
15966 }
15967 return resultobj;
15968 fail:
15969 return NULL;
15970 }
15971
15972
15973 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
15974 PyObject *resultobj;
15975 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15976 bool result;
15977 PyObject * obj0 = 0 ;
15978 char *kwnames[] = {
15979 (char *) "self", NULL
15980 };
15981
15982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
15983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15984 if (SWIG_arg_fail(1)) SWIG_fail;
15985 {
15986 PyThreadState* __tstate = wxPyBeginAllowThreads();
15987 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
15988
15989 wxPyEndAllowThreads(__tstate);
15990 if (PyErr_Occurred()) SWIG_fail;
15991 }
15992 {
15993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15994 }
15995 return resultobj;
15996 fail:
15997 return NULL;
15998 }
15999
16000
16001 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16002 PyObject *resultobj;
16003 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16004 bool result;
16005 PyObject * obj0 = 0 ;
16006 char *kwnames[] = {
16007 (char *) "self", NULL
16008 };
16009
16010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16012 if (SWIG_arg_fail(1)) SWIG_fail;
16013 {
16014 PyThreadState* __tstate = wxPyBeginAllowThreads();
16015 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16016
16017 wxPyEndAllowThreads(__tstate);
16018 if (PyErr_Occurred()) SWIG_fail;
16019 }
16020 {
16021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16022 }
16023 return resultobj;
16024 fail:
16025 return NULL;
16026 }
16027
16028
16029 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16030 PyObject *resultobj;
16031 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16032 bool result;
16033 PyObject * obj0 = 0 ;
16034 char *kwnames[] = {
16035 (char *) "self", NULL
16036 };
16037
16038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16040 if (SWIG_arg_fail(1)) SWIG_fail;
16041 {
16042 PyThreadState* __tstate = wxPyBeginAllowThreads();
16043 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16044
16045 wxPyEndAllowThreads(__tstate);
16046 if (PyErr_Occurred()) SWIG_fail;
16047 }
16048 {
16049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16050 }
16051 return resultobj;
16052 fail:
16053 return NULL;
16054 }
16055
16056
16057 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16058 PyObject *resultobj;
16059 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16060 bool result;
16061 PyObject * obj0 = 0 ;
16062 char *kwnames[] = {
16063 (char *) "self", NULL
16064 };
16065
16066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16068 if (SWIG_arg_fail(1)) SWIG_fail;
16069 {
16070 PyThreadState* __tstate = wxPyBeginAllowThreads();
16071 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16072
16073 wxPyEndAllowThreads(__tstate);
16074 if (PyErr_Occurred()) SWIG_fail;
16075 }
16076 {
16077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16078 }
16079 return resultobj;
16080 fail:
16081 return NULL;
16082 }
16083
16084
16085 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16086 PyObject *resultobj;
16087 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16088 bool result;
16089 PyObject * obj0 = 0 ;
16090 char *kwnames[] = {
16091 (char *) "self", NULL
16092 };
16093
16094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16096 if (SWIG_arg_fail(1)) SWIG_fail;
16097 {
16098 PyThreadState* __tstate = wxPyBeginAllowThreads();
16099 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16100
16101 wxPyEndAllowThreads(__tstate);
16102 if (PyErr_Occurred()) SWIG_fail;
16103 }
16104 {
16105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16106 }
16107 return resultobj;
16108 fail:
16109 return NULL;
16110 }
16111
16112
16113 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16114 PyObject *resultobj;
16115 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16116 bool result;
16117 PyObject * obj0 = 0 ;
16118 char *kwnames[] = {
16119 (char *) "self", NULL
16120 };
16121
16122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16124 if (SWIG_arg_fail(1)) SWIG_fail;
16125 {
16126 PyThreadState* __tstate = wxPyBeginAllowThreads();
16127 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16128
16129 wxPyEndAllowThreads(__tstate);
16130 if (PyErr_Occurred()) SWIG_fail;
16131 }
16132 {
16133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16134 }
16135 return resultobj;
16136 fail:
16137 return NULL;
16138 }
16139
16140
16141 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16142 PyObject *resultobj;
16143 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16144 bool result;
16145 PyObject * obj0 = 0 ;
16146 char *kwnames[] = {
16147 (char *) "self", NULL
16148 };
16149
16150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16152 if (SWIG_arg_fail(1)) SWIG_fail;
16153 {
16154 PyThreadState* __tstate = wxPyBeginAllowThreads();
16155 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16156
16157 wxPyEndAllowThreads(__tstate);
16158 if (PyErr_Occurred()) SWIG_fail;
16159 }
16160 {
16161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16162 }
16163 return resultobj;
16164 fail:
16165 return NULL;
16166 }
16167
16168
16169 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16170 PyObject *resultobj;
16171 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16172 bool result;
16173 PyObject * obj0 = 0 ;
16174 char *kwnames[] = {
16175 (char *) "self", NULL
16176 };
16177
16178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16180 if (SWIG_arg_fail(1)) SWIG_fail;
16181 {
16182 PyThreadState* __tstate = wxPyBeginAllowThreads();
16183 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16184
16185 wxPyEndAllowThreads(__tstate);
16186 if (PyErr_Occurred()) SWIG_fail;
16187 }
16188 {
16189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16190 }
16191 return resultobj;
16192 fail:
16193 return NULL;
16194 }
16195
16196
16197 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16198 PyObject *resultobj;
16199 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16200 bool result;
16201 PyObject * obj0 = 0 ;
16202 char *kwnames[] = {
16203 (char *) "self", NULL
16204 };
16205
16206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16208 if (SWIG_arg_fail(1)) SWIG_fail;
16209 {
16210 PyThreadState* __tstate = wxPyBeginAllowThreads();
16211 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16212
16213 wxPyEndAllowThreads(__tstate);
16214 if (PyErr_Occurred()) SWIG_fail;
16215 }
16216 {
16217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16218 }
16219 return resultobj;
16220 fail:
16221 return NULL;
16222 }
16223
16224
16225 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16226 PyObject *resultobj;
16227 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16228 bool result;
16229 PyObject * obj0 = 0 ;
16230 char *kwnames[] = {
16231 (char *) "self", NULL
16232 };
16233
16234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16236 if (SWIG_arg_fail(1)) SWIG_fail;
16237 {
16238 PyThreadState* __tstate = wxPyBeginAllowThreads();
16239 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16240
16241 wxPyEndAllowThreads(__tstate);
16242 if (PyErr_Occurred()) SWIG_fail;
16243 }
16244 {
16245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16246 }
16247 return resultobj;
16248 fail:
16249 return NULL;
16250 }
16251
16252
16253 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16254 PyObject *resultobj;
16255 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16256 bool result;
16257 PyObject * obj0 = 0 ;
16258 char *kwnames[] = {
16259 (char *) "self", NULL
16260 };
16261
16262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16264 if (SWIG_arg_fail(1)) SWIG_fail;
16265 {
16266 PyThreadState* __tstate = wxPyBeginAllowThreads();
16267 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16268
16269 wxPyEndAllowThreads(__tstate);
16270 if (PyErr_Occurred()) SWIG_fail;
16271 }
16272 {
16273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16274 }
16275 return resultobj;
16276 fail:
16277 return NULL;
16278 }
16279
16280
16281 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16282 PyObject *resultobj;
16283 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16284 bool result;
16285 PyObject * obj0 = 0 ;
16286 char *kwnames[] = {
16287 (char *) "self", NULL
16288 };
16289
16290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16292 if (SWIG_arg_fail(1)) SWIG_fail;
16293 {
16294 PyThreadState* __tstate = wxPyBeginAllowThreads();
16295 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16296
16297 wxPyEndAllowThreads(__tstate);
16298 if (PyErr_Occurred()) SWIG_fail;
16299 }
16300 {
16301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16302 }
16303 return resultobj;
16304 fail:
16305 return NULL;
16306 }
16307
16308
16309 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16310 PyObject *resultobj;
16311 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16312 bool result;
16313 PyObject * obj0 = 0 ;
16314 char *kwnames[] = {
16315 (char *) "self", NULL
16316 };
16317
16318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16320 if (SWIG_arg_fail(1)) SWIG_fail;
16321 {
16322 PyThreadState* __tstate = wxPyBeginAllowThreads();
16323 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16324
16325 wxPyEndAllowThreads(__tstate);
16326 if (PyErr_Occurred()) SWIG_fail;
16327 }
16328 {
16329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16330 }
16331 return resultobj;
16332 fail:
16333 return NULL;
16334 }
16335
16336
16337 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16338 PyObject *resultobj;
16339 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16340 bool result;
16341 PyObject * obj0 = 0 ;
16342 char *kwnames[] = {
16343 (char *) "self", NULL
16344 };
16345
16346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16348 if (SWIG_arg_fail(1)) SWIG_fail;
16349 {
16350 PyThreadState* __tstate = wxPyBeginAllowThreads();
16351 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16352
16353 wxPyEndAllowThreads(__tstate);
16354 if (PyErr_Occurred()) SWIG_fail;
16355 }
16356 {
16357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16358 }
16359 return resultobj;
16360 fail:
16361 return NULL;
16362 }
16363
16364
16365 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16366 PyObject *resultobj;
16367 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16368 bool result;
16369 PyObject * obj0 = 0 ;
16370 char *kwnames[] = {
16371 (char *) "self", NULL
16372 };
16373
16374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16376 if (SWIG_arg_fail(1)) SWIG_fail;
16377 {
16378 PyThreadState* __tstate = wxPyBeginAllowThreads();
16379 result = (bool)(arg1)->LeftIsDown();
16380
16381 wxPyEndAllowThreads(__tstate);
16382 if (PyErr_Occurred()) SWIG_fail;
16383 }
16384 {
16385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16386 }
16387 return resultobj;
16388 fail:
16389 return NULL;
16390 }
16391
16392
16393 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16394 PyObject *resultobj;
16395 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16396 bool result;
16397 PyObject * obj0 = 0 ;
16398 char *kwnames[] = {
16399 (char *) "self", NULL
16400 };
16401
16402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16404 if (SWIG_arg_fail(1)) SWIG_fail;
16405 {
16406 PyThreadState* __tstate = wxPyBeginAllowThreads();
16407 result = (bool)(arg1)->MiddleIsDown();
16408
16409 wxPyEndAllowThreads(__tstate);
16410 if (PyErr_Occurred()) SWIG_fail;
16411 }
16412 {
16413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16414 }
16415 return resultobj;
16416 fail:
16417 return NULL;
16418 }
16419
16420
16421 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16422 PyObject *resultobj;
16423 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16424 bool result;
16425 PyObject * obj0 = 0 ;
16426 char *kwnames[] = {
16427 (char *) "self", NULL
16428 };
16429
16430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16432 if (SWIG_arg_fail(1)) SWIG_fail;
16433 {
16434 PyThreadState* __tstate = wxPyBeginAllowThreads();
16435 result = (bool)(arg1)->RightIsDown();
16436
16437 wxPyEndAllowThreads(__tstate);
16438 if (PyErr_Occurred()) SWIG_fail;
16439 }
16440 {
16441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16442 }
16443 return resultobj;
16444 fail:
16445 return NULL;
16446 }
16447
16448
16449 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16450 PyObject *resultobj;
16451 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16452 bool result;
16453 PyObject * obj0 = 0 ;
16454 char *kwnames[] = {
16455 (char *) "self", NULL
16456 };
16457
16458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16460 if (SWIG_arg_fail(1)) SWIG_fail;
16461 {
16462 PyThreadState* __tstate = wxPyBeginAllowThreads();
16463 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16464
16465 wxPyEndAllowThreads(__tstate);
16466 if (PyErr_Occurred()) SWIG_fail;
16467 }
16468 {
16469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16470 }
16471 return resultobj;
16472 fail:
16473 return NULL;
16474 }
16475
16476
16477 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16478 PyObject *resultobj;
16479 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16480 bool result;
16481 PyObject * obj0 = 0 ;
16482 char *kwnames[] = {
16483 (char *) "self", NULL
16484 };
16485
16486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16488 if (SWIG_arg_fail(1)) SWIG_fail;
16489 {
16490 PyThreadState* __tstate = wxPyBeginAllowThreads();
16491 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16492
16493 wxPyEndAllowThreads(__tstate);
16494 if (PyErr_Occurred()) SWIG_fail;
16495 }
16496 {
16497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16498 }
16499 return resultobj;
16500 fail:
16501 return NULL;
16502 }
16503
16504
16505 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16506 PyObject *resultobj;
16507 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16508 bool result;
16509 PyObject * obj0 = 0 ;
16510 char *kwnames[] = {
16511 (char *) "self", NULL
16512 };
16513
16514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16516 if (SWIG_arg_fail(1)) SWIG_fail;
16517 {
16518 PyThreadState* __tstate = wxPyBeginAllowThreads();
16519 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16520
16521 wxPyEndAllowThreads(__tstate);
16522 if (PyErr_Occurred()) SWIG_fail;
16523 }
16524 {
16525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16526 }
16527 return resultobj;
16528 fail:
16529 return NULL;
16530 }
16531
16532
16533 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
16534 PyObject *resultobj;
16535 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16536 bool result;
16537 PyObject * obj0 = 0 ;
16538 char *kwnames[] = {
16539 (char *) "self", NULL
16540 };
16541
16542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
16543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16544 if (SWIG_arg_fail(1)) SWIG_fail;
16545 {
16546 PyThreadState* __tstate = wxPyBeginAllowThreads();
16547 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
16548
16549 wxPyEndAllowThreads(__tstate);
16550 if (PyErr_Occurred()) SWIG_fail;
16551 }
16552 {
16553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16554 }
16555 return resultobj;
16556 fail:
16557 return NULL;
16558 }
16559
16560
16561 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16562 PyObject *resultobj;
16563 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16564 wxPoint result;
16565 PyObject * obj0 = 0 ;
16566 char *kwnames[] = {
16567 (char *) "self", NULL
16568 };
16569
16570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
16571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16572 if (SWIG_arg_fail(1)) SWIG_fail;
16573 {
16574 PyThreadState* __tstate = wxPyBeginAllowThreads();
16575 result = (arg1)->GetPosition();
16576
16577 wxPyEndAllowThreads(__tstate);
16578 if (PyErr_Occurred()) SWIG_fail;
16579 }
16580 {
16581 wxPoint * resultptr;
16582 resultptr = new wxPoint((wxPoint &)(result));
16583 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16584 }
16585 return resultobj;
16586 fail:
16587 return NULL;
16588 }
16589
16590
16591 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16592 PyObject *resultobj;
16593 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16594 long *arg2 = (long *) 0 ;
16595 long *arg3 = (long *) 0 ;
16596 long temp2 ;
16597 int res2 = 0 ;
16598 long temp3 ;
16599 int res3 = 0 ;
16600 PyObject * obj0 = 0 ;
16601 char *kwnames[] = {
16602 (char *) "self", NULL
16603 };
16604
16605 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16606 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
16608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16609 if (SWIG_arg_fail(1)) SWIG_fail;
16610 {
16611 PyThreadState* __tstate = wxPyBeginAllowThreads();
16612 (arg1)->GetPosition(arg2,arg3);
16613
16614 wxPyEndAllowThreads(__tstate);
16615 if (PyErr_Occurred()) SWIG_fail;
16616 }
16617 Py_INCREF(Py_None); resultobj = Py_None;
16618 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16619 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
16620 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16621 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
16622 return resultobj;
16623 fail:
16624 return NULL;
16625 }
16626
16627
16628 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16629 PyObject *resultobj;
16630 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16631 wxDC *arg2 = 0 ;
16632 wxPoint result;
16633 PyObject * obj0 = 0 ;
16634 PyObject * obj1 = 0 ;
16635 char *kwnames[] = {
16636 (char *) "self",(char *) "dc", NULL
16637 };
16638
16639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
16640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16641 if (SWIG_arg_fail(1)) SWIG_fail;
16642 {
16643 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16644 if (SWIG_arg_fail(2)) SWIG_fail;
16645 if (arg2 == NULL) {
16646 SWIG_null_ref("wxDC");
16647 }
16648 if (SWIG_arg_fail(2)) SWIG_fail;
16649 }
16650 {
16651 PyThreadState* __tstate = wxPyBeginAllowThreads();
16652 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
16653
16654 wxPyEndAllowThreads(__tstate);
16655 if (PyErr_Occurred()) SWIG_fail;
16656 }
16657 {
16658 wxPoint * resultptr;
16659 resultptr = new wxPoint((wxPoint &)(result));
16660 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16661 }
16662 return resultobj;
16663 fail:
16664 return NULL;
16665 }
16666
16667
16668 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
16669 PyObject *resultobj;
16670 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16671 int result;
16672 PyObject * obj0 = 0 ;
16673 char *kwnames[] = {
16674 (char *) "self", NULL
16675 };
16676
16677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
16678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16679 if (SWIG_arg_fail(1)) SWIG_fail;
16680 {
16681 PyThreadState* __tstate = wxPyBeginAllowThreads();
16682 result = (int)((wxMouseEvent const *)arg1)->GetX();
16683
16684 wxPyEndAllowThreads(__tstate);
16685 if (PyErr_Occurred()) SWIG_fail;
16686 }
16687 {
16688 resultobj = SWIG_From_int((int)(result));
16689 }
16690 return resultobj;
16691 fail:
16692 return NULL;
16693 }
16694
16695
16696 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
16697 PyObject *resultobj;
16698 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16699 int result;
16700 PyObject * obj0 = 0 ;
16701 char *kwnames[] = {
16702 (char *) "self", NULL
16703 };
16704
16705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
16706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16707 if (SWIG_arg_fail(1)) SWIG_fail;
16708 {
16709 PyThreadState* __tstate = wxPyBeginAllowThreads();
16710 result = (int)((wxMouseEvent const *)arg1)->GetY();
16711
16712 wxPyEndAllowThreads(__tstate);
16713 if (PyErr_Occurred()) SWIG_fail;
16714 }
16715 {
16716 resultobj = SWIG_From_int((int)(result));
16717 }
16718 return resultobj;
16719 fail:
16720 return NULL;
16721 }
16722
16723
16724 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
16725 PyObject *resultobj;
16726 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16727 int result;
16728 PyObject * obj0 = 0 ;
16729 char *kwnames[] = {
16730 (char *) "self", NULL
16731 };
16732
16733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
16734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16735 if (SWIG_arg_fail(1)) SWIG_fail;
16736 {
16737 PyThreadState* __tstate = wxPyBeginAllowThreads();
16738 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
16739
16740 wxPyEndAllowThreads(__tstate);
16741 if (PyErr_Occurred()) SWIG_fail;
16742 }
16743 {
16744 resultobj = SWIG_From_int((int)(result));
16745 }
16746 return resultobj;
16747 fail:
16748 return NULL;
16749 }
16750
16751
16752 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
16753 PyObject *resultobj;
16754 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16755 int result;
16756 PyObject * obj0 = 0 ;
16757 char *kwnames[] = {
16758 (char *) "self", NULL
16759 };
16760
16761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
16762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16763 if (SWIG_arg_fail(1)) SWIG_fail;
16764 {
16765 PyThreadState* __tstate = wxPyBeginAllowThreads();
16766 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
16767
16768 wxPyEndAllowThreads(__tstate);
16769 if (PyErr_Occurred()) SWIG_fail;
16770 }
16771 {
16772 resultobj = SWIG_From_int((int)(result));
16773 }
16774 return resultobj;
16775 fail:
16776 return NULL;
16777 }
16778
16779
16780 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
16781 PyObject *resultobj;
16782 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16783 int result;
16784 PyObject * obj0 = 0 ;
16785 char *kwnames[] = {
16786 (char *) "self", NULL
16787 };
16788
16789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
16790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16791 if (SWIG_arg_fail(1)) SWIG_fail;
16792 {
16793 PyThreadState* __tstate = wxPyBeginAllowThreads();
16794 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
16795
16796 wxPyEndAllowThreads(__tstate);
16797 if (PyErr_Occurred()) SWIG_fail;
16798 }
16799 {
16800 resultobj = SWIG_From_int((int)(result));
16801 }
16802 return resultobj;
16803 fail:
16804 return NULL;
16805 }
16806
16807
16808 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
16809 PyObject *resultobj;
16810 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16811 bool result;
16812 PyObject * obj0 = 0 ;
16813 char *kwnames[] = {
16814 (char *) "self", NULL
16815 };
16816
16817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
16818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16819 if (SWIG_arg_fail(1)) SWIG_fail;
16820 {
16821 PyThreadState* __tstate = wxPyBeginAllowThreads();
16822 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
16823
16824 wxPyEndAllowThreads(__tstate);
16825 if (PyErr_Occurred()) SWIG_fail;
16826 }
16827 {
16828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16829 }
16830 return resultobj;
16831 fail:
16832 return NULL;
16833 }
16834
16835
16836 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
16837 PyObject *resultobj;
16838 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16839 int arg2 ;
16840 PyObject * obj0 = 0 ;
16841 PyObject * obj1 = 0 ;
16842 char *kwnames[] = {
16843 (char *) "self",(char *) "m_x", NULL
16844 };
16845
16846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
16847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16848 if (SWIG_arg_fail(1)) SWIG_fail;
16849 {
16850 arg2 = (int)(SWIG_As_int(obj1));
16851 if (SWIG_arg_fail(2)) SWIG_fail;
16852 }
16853 if (arg1) (arg1)->m_x = arg2;
16854
16855 Py_INCREF(Py_None); resultobj = Py_None;
16856 return resultobj;
16857 fail:
16858 return NULL;
16859 }
16860
16861
16862 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
16863 PyObject *resultobj;
16864 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16865 int result;
16866 PyObject * obj0 = 0 ;
16867 char *kwnames[] = {
16868 (char *) "self", NULL
16869 };
16870
16871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
16872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16873 if (SWIG_arg_fail(1)) SWIG_fail;
16874 result = (int) ((arg1)->m_x);
16875
16876 {
16877 resultobj = SWIG_From_int((int)(result));
16878 }
16879 return resultobj;
16880 fail:
16881 return NULL;
16882 }
16883
16884
16885 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
16886 PyObject *resultobj;
16887 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16888 int arg2 ;
16889 PyObject * obj0 = 0 ;
16890 PyObject * obj1 = 0 ;
16891 char *kwnames[] = {
16892 (char *) "self",(char *) "m_y", NULL
16893 };
16894
16895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
16896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16897 if (SWIG_arg_fail(1)) SWIG_fail;
16898 {
16899 arg2 = (int)(SWIG_As_int(obj1));
16900 if (SWIG_arg_fail(2)) SWIG_fail;
16901 }
16902 if (arg1) (arg1)->m_y = arg2;
16903
16904 Py_INCREF(Py_None); resultobj = Py_None;
16905 return resultobj;
16906 fail:
16907 return NULL;
16908 }
16909
16910
16911 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
16912 PyObject *resultobj;
16913 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16914 int result;
16915 PyObject * obj0 = 0 ;
16916 char *kwnames[] = {
16917 (char *) "self", NULL
16918 };
16919
16920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
16921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16922 if (SWIG_arg_fail(1)) SWIG_fail;
16923 result = (int) ((arg1)->m_y);
16924
16925 {
16926 resultobj = SWIG_From_int((int)(result));
16927 }
16928 return resultobj;
16929 fail:
16930 return NULL;
16931 }
16932
16933
16934 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
16935 PyObject *resultobj;
16936 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16937 bool arg2 ;
16938 PyObject * obj0 = 0 ;
16939 PyObject * obj1 = 0 ;
16940 char *kwnames[] = {
16941 (char *) "self",(char *) "m_leftDown", NULL
16942 };
16943
16944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
16945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16946 if (SWIG_arg_fail(1)) SWIG_fail;
16947 {
16948 arg2 = (bool)(SWIG_As_bool(obj1));
16949 if (SWIG_arg_fail(2)) SWIG_fail;
16950 }
16951 if (arg1) (arg1)->m_leftDown = arg2;
16952
16953 Py_INCREF(Py_None); resultobj = Py_None;
16954 return resultobj;
16955 fail:
16956 return NULL;
16957 }
16958
16959
16960 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
16961 PyObject *resultobj;
16962 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16963 bool result;
16964 PyObject * obj0 = 0 ;
16965 char *kwnames[] = {
16966 (char *) "self", NULL
16967 };
16968
16969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
16970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16971 if (SWIG_arg_fail(1)) SWIG_fail;
16972 result = (bool) ((arg1)->m_leftDown);
16973
16974 {
16975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16976 }
16977 return resultobj;
16978 fail:
16979 return NULL;
16980 }
16981
16982
16983 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
16984 PyObject *resultobj;
16985 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16986 bool arg2 ;
16987 PyObject * obj0 = 0 ;
16988 PyObject * obj1 = 0 ;
16989 char *kwnames[] = {
16990 (char *) "self",(char *) "m_middleDown", NULL
16991 };
16992
16993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
16994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16995 if (SWIG_arg_fail(1)) SWIG_fail;
16996 {
16997 arg2 = (bool)(SWIG_As_bool(obj1));
16998 if (SWIG_arg_fail(2)) SWIG_fail;
16999 }
17000 if (arg1) (arg1)->m_middleDown = arg2;
17001
17002 Py_INCREF(Py_None); resultobj = Py_None;
17003 return resultobj;
17004 fail:
17005 return NULL;
17006 }
17007
17008
17009 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17010 PyObject *resultobj;
17011 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17012 bool result;
17013 PyObject * obj0 = 0 ;
17014 char *kwnames[] = {
17015 (char *) "self", NULL
17016 };
17017
17018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17020 if (SWIG_arg_fail(1)) SWIG_fail;
17021 result = (bool) ((arg1)->m_middleDown);
17022
17023 {
17024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17025 }
17026 return resultobj;
17027 fail:
17028 return NULL;
17029 }
17030
17031
17032 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17033 PyObject *resultobj;
17034 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17035 bool arg2 ;
17036 PyObject * obj0 = 0 ;
17037 PyObject * obj1 = 0 ;
17038 char *kwnames[] = {
17039 (char *) "self",(char *) "m_rightDown", NULL
17040 };
17041
17042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17044 if (SWIG_arg_fail(1)) SWIG_fail;
17045 {
17046 arg2 = (bool)(SWIG_As_bool(obj1));
17047 if (SWIG_arg_fail(2)) SWIG_fail;
17048 }
17049 if (arg1) (arg1)->m_rightDown = arg2;
17050
17051 Py_INCREF(Py_None); resultobj = Py_None;
17052 return resultobj;
17053 fail:
17054 return NULL;
17055 }
17056
17057
17058 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17059 PyObject *resultobj;
17060 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17061 bool result;
17062 PyObject * obj0 = 0 ;
17063 char *kwnames[] = {
17064 (char *) "self", NULL
17065 };
17066
17067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17069 if (SWIG_arg_fail(1)) SWIG_fail;
17070 result = (bool) ((arg1)->m_rightDown);
17071
17072 {
17073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17074 }
17075 return resultobj;
17076 fail:
17077 return NULL;
17078 }
17079
17080
17081 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17082 PyObject *resultobj;
17083 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17084 bool arg2 ;
17085 PyObject * obj0 = 0 ;
17086 PyObject * obj1 = 0 ;
17087 char *kwnames[] = {
17088 (char *) "self",(char *) "m_controlDown", NULL
17089 };
17090
17091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17093 if (SWIG_arg_fail(1)) SWIG_fail;
17094 {
17095 arg2 = (bool)(SWIG_As_bool(obj1));
17096 if (SWIG_arg_fail(2)) SWIG_fail;
17097 }
17098 if (arg1) (arg1)->m_controlDown = arg2;
17099
17100 Py_INCREF(Py_None); resultobj = Py_None;
17101 return resultobj;
17102 fail:
17103 return NULL;
17104 }
17105
17106
17107 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17108 PyObject *resultobj;
17109 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17110 bool result;
17111 PyObject * obj0 = 0 ;
17112 char *kwnames[] = {
17113 (char *) "self", NULL
17114 };
17115
17116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17118 if (SWIG_arg_fail(1)) SWIG_fail;
17119 result = (bool) ((arg1)->m_controlDown);
17120
17121 {
17122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17123 }
17124 return resultobj;
17125 fail:
17126 return NULL;
17127 }
17128
17129
17130 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17131 PyObject *resultobj;
17132 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17133 bool arg2 ;
17134 PyObject * obj0 = 0 ;
17135 PyObject * obj1 = 0 ;
17136 char *kwnames[] = {
17137 (char *) "self",(char *) "m_shiftDown", NULL
17138 };
17139
17140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17142 if (SWIG_arg_fail(1)) SWIG_fail;
17143 {
17144 arg2 = (bool)(SWIG_As_bool(obj1));
17145 if (SWIG_arg_fail(2)) SWIG_fail;
17146 }
17147 if (arg1) (arg1)->m_shiftDown = arg2;
17148
17149 Py_INCREF(Py_None); resultobj = Py_None;
17150 return resultobj;
17151 fail:
17152 return NULL;
17153 }
17154
17155
17156 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17157 PyObject *resultobj;
17158 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17159 bool result;
17160 PyObject * obj0 = 0 ;
17161 char *kwnames[] = {
17162 (char *) "self", NULL
17163 };
17164
17165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17167 if (SWIG_arg_fail(1)) SWIG_fail;
17168 result = (bool) ((arg1)->m_shiftDown);
17169
17170 {
17171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17172 }
17173 return resultobj;
17174 fail:
17175 return NULL;
17176 }
17177
17178
17179 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17180 PyObject *resultobj;
17181 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17182 bool arg2 ;
17183 PyObject * obj0 = 0 ;
17184 PyObject * obj1 = 0 ;
17185 char *kwnames[] = {
17186 (char *) "self",(char *) "m_altDown", NULL
17187 };
17188
17189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17191 if (SWIG_arg_fail(1)) SWIG_fail;
17192 {
17193 arg2 = (bool)(SWIG_As_bool(obj1));
17194 if (SWIG_arg_fail(2)) SWIG_fail;
17195 }
17196 if (arg1) (arg1)->m_altDown = arg2;
17197
17198 Py_INCREF(Py_None); resultobj = Py_None;
17199 return resultobj;
17200 fail:
17201 return NULL;
17202 }
17203
17204
17205 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17206 PyObject *resultobj;
17207 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17208 bool result;
17209 PyObject * obj0 = 0 ;
17210 char *kwnames[] = {
17211 (char *) "self", NULL
17212 };
17213
17214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17216 if (SWIG_arg_fail(1)) SWIG_fail;
17217 result = (bool) ((arg1)->m_altDown);
17218
17219 {
17220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17221 }
17222 return resultobj;
17223 fail:
17224 return NULL;
17225 }
17226
17227
17228 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17229 PyObject *resultobj;
17230 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17231 bool arg2 ;
17232 PyObject * obj0 = 0 ;
17233 PyObject * obj1 = 0 ;
17234 char *kwnames[] = {
17235 (char *) "self",(char *) "m_metaDown", NULL
17236 };
17237
17238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17240 if (SWIG_arg_fail(1)) SWIG_fail;
17241 {
17242 arg2 = (bool)(SWIG_As_bool(obj1));
17243 if (SWIG_arg_fail(2)) SWIG_fail;
17244 }
17245 if (arg1) (arg1)->m_metaDown = arg2;
17246
17247 Py_INCREF(Py_None); resultobj = Py_None;
17248 return resultobj;
17249 fail:
17250 return NULL;
17251 }
17252
17253
17254 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17255 PyObject *resultobj;
17256 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17257 bool result;
17258 PyObject * obj0 = 0 ;
17259 char *kwnames[] = {
17260 (char *) "self", NULL
17261 };
17262
17263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17265 if (SWIG_arg_fail(1)) SWIG_fail;
17266 result = (bool) ((arg1)->m_metaDown);
17267
17268 {
17269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17270 }
17271 return resultobj;
17272 fail:
17273 return NULL;
17274 }
17275
17276
17277 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17278 PyObject *resultobj;
17279 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17280 int arg2 ;
17281 PyObject * obj0 = 0 ;
17282 PyObject * obj1 = 0 ;
17283 char *kwnames[] = {
17284 (char *) "self",(char *) "m_wheelRotation", NULL
17285 };
17286
17287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17289 if (SWIG_arg_fail(1)) SWIG_fail;
17290 {
17291 arg2 = (int)(SWIG_As_int(obj1));
17292 if (SWIG_arg_fail(2)) SWIG_fail;
17293 }
17294 if (arg1) (arg1)->m_wheelRotation = arg2;
17295
17296 Py_INCREF(Py_None); resultobj = Py_None;
17297 return resultobj;
17298 fail:
17299 return NULL;
17300 }
17301
17302
17303 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17304 PyObject *resultobj;
17305 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17306 int result;
17307 PyObject * obj0 = 0 ;
17308 char *kwnames[] = {
17309 (char *) "self", NULL
17310 };
17311
17312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17314 if (SWIG_arg_fail(1)) SWIG_fail;
17315 result = (int) ((arg1)->m_wheelRotation);
17316
17317 {
17318 resultobj = SWIG_From_int((int)(result));
17319 }
17320 return resultobj;
17321 fail:
17322 return NULL;
17323 }
17324
17325
17326 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17327 PyObject *resultobj;
17328 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17329 int arg2 ;
17330 PyObject * obj0 = 0 ;
17331 PyObject * obj1 = 0 ;
17332 char *kwnames[] = {
17333 (char *) "self",(char *) "m_wheelDelta", NULL
17334 };
17335
17336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17338 if (SWIG_arg_fail(1)) SWIG_fail;
17339 {
17340 arg2 = (int)(SWIG_As_int(obj1));
17341 if (SWIG_arg_fail(2)) SWIG_fail;
17342 }
17343 if (arg1) (arg1)->m_wheelDelta = arg2;
17344
17345 Py_INCREF(Py_None); resultobj = Py_None;
17346 return resultobj;
17347 fail:
17348 return NULL;
17349 }
17350
17351
17352 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17353 PyObject *resultobj;
17354 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17355 int result;
17356 PyObject * obj0 = 0 ;
17357 char *kwnames[] = {
17358 (char *) "self", NULL
17359 };
17360
17361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17363 if (SWIG_arg_fail(1)) SWIG_fail;
17364 result = (int) ((arg1)->m_wheelDelta);
17365
17366 {
17367 resultobj = SWIG_From_int((int)(result));
17368 }
17369 return resultobj;
17370 fail:
17371 return NULL;
17372 }
17373
17374
17375 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17376 PyObject *resultobj;
17377 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17378 int arg2 ;
17379 PyObject * obj0 = 0 ;
17380 PyObject * obj1 = 0 ;
17381 char *kwnames[] = {
17382 (char *) "self",(char *) "m_linesPerAction", NULL
17383 };
17384
17385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17387 if (SWIG_arg_fail(1)) SWIG_fail;
17388 {
17389 arg2 = (int)(SWIG_As_int(obj1));
17390 if (SWIG_arg_fail(2)) SWIG_fail;
17391 }
17392 if (arg1) (arg1)->m_linesPerAction = arg2;
17393
17394 Py_INCREF(Py_None); resultobj = Py_None;
17395 return resultobj;
17396 fail:
17397 return NULL;
17398 }
17399
17400
17401 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17402 PyObject *resultobj;
17403 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17404 int result;
17405 PyObject * obj0 = 0 ;
17406 char *kwnames[] = {
17407 (char *) "self", NULL
17408 };
17409
17410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17412 if (SWIG_arg_fail(1)) SWIG_fail;
17413 result = (int) ((arg1)->m_linesPerAction);
17414
17415 {
17416 resultobj = SWIG_From_int((int)(result));
17417 }
17418 return resultobj;
17419 fail:
17420 return NULL;
17421 }
17422
17423
17424 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17425 PyObject *obj;
17426 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17427 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17428 Py_INCREF(obj);
17429 return Py_BuildValue((char *)"");
17430 }
17431 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17432 PyObject *resultobj;
17433 int arg1 = (int) 0 ;
17434 int arg2 = (int) 0 ;
17435 wxSetCursorEvent *result;
17436 PyObject * obj0 = 0 ;
17437 PyObject * obj1 = 0 ;
17438 char *kwnames[] = {
17439 (char *) "x",(char *) "y", NULL
17440 };
17441
17442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17443 if (obj0) {
17444 {
17445 arg1 = (int)(SWIG_As_int(obj0));
17446 if (SWIG_arg_fail(1)) SWIG_fail;
17447 }
17448 }
17449 if (obj1) {
17450 {
17451 arg2 = (int)(SWIG_As_int(obj1));
17452 if (SWIG_arg_fail(2)) SWIG_fail;
17453 }
17454 }
17455 {
17456 PyThreadState* __tstate = wxPyBeginAllowThreads();
17457 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17458
17459 wxPyEndAllowThreads(__tstate);
17460 if (PyErr_Occurred()) SWIG_fail;
17461 }
17462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17463 return resultobj;
17464 fail:
17465 return NULL;
17466 }
17467
17468
17469 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17470 PyObject *resultobj;
17471 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17472 int result;
17473 PyObject * obj0 = 0 ;
17474 char *kwnames[] = {
17475 (char *) "self", NULL
17476 };
17477
17478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17480 if (SWIG_arg_fail(1)) SWIG_fail;
17481 {
17482 PyThreadState* __tstate = wxPyBeginAllowThreads();
17483 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17484
17485 wxPyEndAllowThreads(__tstate);
17486 if (PyErr_Occurred()) SWIG_fail;
17487 }
17488 {
17489 resultobj = SWIG_From_int((int)(result));
17490 }
17491 return resultobj;
17492 fail:
17493 return NULL;
17494 }
17495
17496
17497 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17498 PyObject *resultobj;
17499 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17500 int result;
17501 PyObject * obj0 = 0 ;
17502 char *kwnames[] = {
17503 (char *) "self", NULL
17504 };
17505
17506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17508 if (SWIG_arg_fail(1)) SWIG_fail;
17509 {
17510 PyThreadState* __tstate = wxPyBeginAllowThreads();
17511 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17512
17513 wxPyEndAllowThreads(__tstate);
17514 if (PyErr_Occurred()) SWIG_fail;
17515 }
17516 {
17517 resultobj = SWIG_From_int((int)(result));
17518 }
17519 return resultobj;
17520 fail:
17521 return NULL;
17522 }
17523
17524
17525 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17526 PyObject *resultobj;
17527 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17528 wxCursor *arg2 = 0 ;
17529 PyObject * obj0 = 0 ;
17530 PyObject * obj1 = 0 ;
17531 char *kwnames[] = {
17532 (char *) "self",(char *) "cursor", NULL
17533 };
17534
17535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
17536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17537 if (SWIG_arg_fail(1)) SWIG_fail;
17538 {
17539 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
17540 if (SWIG_arg_fail(2)) SWIG_fail;
17541 if (arg2 == NULL) {
17542 SWIG_null_ref("wxCursor");
17543 }
17544 if (SWIG_arg_fail(2)) SWIG_fail;
17545 }
17546 {
17547 PyThreadState* __tstate = wxPyBeginAllowThreads();
17548 (arg1)->SetCursor((wxCursor const &)*arg2);
17549
17550 wxPyEndAllowThreads(__tstate);
17551 if (PyErr_Occurred()) SWIG_fail;
17552 }
17553 Py_INCREF(Py_None); resultobj = Py_None;
17554 return resultobj;
17555 fail:
17556 return NULL;
17557 }
17558
17559
17560 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17561 PyObject *resultobj;
17562 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17563 wxCursor *result;
17564 PyObject * obj0 = 0 ;
17565 char *kwnames[] = {
17566 (char *) "self", NULL
17567 };
17568
17569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
17570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17571 if (SWIG_arg_fail(1)) SWIG_fail;
17572 {
17573 PyThreadState* __tstate = wxPyBeginAllowThreads();
17574 {
17575 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
17576 result = (wxCursor *) &_result_ref;
17577 }
17578
17579 wxPyEndAllowThreads(__tstate);
17580 if (PyErr_Occurred()) SWIG_fail;
17581 }
17582 {
17583 wxCursor* resultptr = new wxCursor(*result);
17584 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
17585 }
17586 return resultobj;
17587 fail:
17588 return NULL;
17589 }
17590
17591
17592 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17593 PyObject *resultobj;
17594 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17595 bool result;
17596 PyObject * obj0 = 0 ;
17597 char *kwnames[] = {
17598 (char *) "self", NULL
17599 };
17600
17601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
17602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17603 if (SWIG_arg_fail(1)) SWIG_fail;
17604 {
17605 PyThreadState* __tstate = wxPyBeginAllowThreads();
17606 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
17607
17608 wxPyEndAllowThreads(__tstate);
17609 if (PyErr_Occurred()) SWIG_fail;
17610 }
17611 {
17612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17613 }
17614 return resultobj;
17615 fail:
17616 return NULL;
17617 }
17618
17619
17620 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
17621 PyObject *obj;
17622 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17623 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
17624 Py_INCREF(obj);
17625 return Py_BuildValue((char *)"");
17626 }
17627 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17628 PyObject *resultobj;
17629 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17630 wxKeyEvent *result;
17631 PyObject * obj0 = 0 ;
17632 char *kwnames[] = {
17633 (char *) "keyType", NULL
17634 };
17635
17636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
17637 if (obj0) {
17638 {
17639 arg1 = (wxEventType)(SWIG_As_int(obj0));
17640 if (SWIG_arg_fail(1)) SWIG_fail;
17641 }
17642 }
17643 {
17644 PyThreadState* __tstate = wxPyBeginAllowThreads();
17645 result = (wxKeyEvent *)new wxKeyEvent(arg1);
17646
17647 wxPyEndAllowThreads(__tstate);
17648 if (PyErr_Occurred()) SWIG_fail;
17649 }
17650 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
17651 return resultobj;
17652 fail:
17653 return NULL;
17654 }
17655
17656
17657 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17658 PyObject *resultobj;
17659 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17660 bool result;
17661 PyObject * obj0 = 0 ;
17662 char *kwnames[] = {
17663 (char *) "self", NULL
17664 };
17665
17666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
17667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17668 if (SWIG_arg_fail(1)) SWIG_fail;
17669 {
17670 PyThreadState* __tstate = wxPyBeginAllowThreads();
17671 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
17672
17673 wxPyEndAllowThreads(__tstate);
17674 if (PyErr_Occurred()) SWIG_fail;
17675 }
17676 {
17677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17678 }
17679 return resultobj;
17680 fail:
17681 return NULL;
17682 }
17683
17684
17685 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17686 PyObject *resultobj;
17687 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17688 bool result;
17689 PyObject * obj0 = 0 ;
17690 char *kwnames[] = {
17691 (char *) "self", NULL
17692 };
17693
17694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
17695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17696 if (SWIG_arg_fail(1)) SWIG_fail;
17697 {
17698 PyThreadState* __tstate = wxPyBeginAllowThreads();
17699 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
17700
17701 wxPyEndAllowThreads(__tstate);
17702 if (PyErr_Occurred()) SWIG_fail;
17703 }
17704 {
17705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17706 }
17707 return resultobj;
17708 fail:
17709 return NULL;
17710 }
17711
17712
17713 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17714 PyObject *resultobj;
17715 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17716 bool result;
17717 PyObject * obj0 = 0 ;
17718 char *kwnames[] = {
17719 (char *) "self", NULL
17720 };
17721
17722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
17723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17724 if (SWIG_arg_fail(1)) SWIG_fail;
17725 {
17726 PyThreadState* __tstate = wxPyBeginAllowThreads();
17727 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
17728
17729 wxPyEndAllowThreads(__tstate);
17730 if (PyErr_Occurred()) SWIG_fail;
17731 }
17732 {
17733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17734 }
17735 return resultobj;
17736 fail:
17737 return NULL;
17738 }
17739
17740
17741 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17742 PyObject *resultobj;
17743 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17744 bool result;
17745 PyObject * obj0 = 0 ;
17746 char *kwnames[] = {
17747 (char *) "self", NULL
17748 };
17749
17750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
17751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17752 if (SWIG_arg_fail(1)) SWIG_fail;
17753 {
17754 PyThreadState* __tstate = wxPyBeginAllowThreads();
17755 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
17756
17757 wxPyEndAllowThreads(__tstate);
17758 if (PyErr_Occurred()) SWIG_fail;
17759 }
17760 {
17761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17762 }
17763 return resultobj;
17764 fail:
17765 return NULL;
17766 }
17767
17768
17769 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17770 PyObject *resultobj;
17771 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17772 bool result;
17773 PyObject * obj0 = 0 ;
17774 char *kwnames[] = {
17775 (char *) "self", NULL
17776 };
17777
17778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
17779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17780 if (SWIG_arg_fail(1)) SWIG_fail;
17781 {
17782 PyThreadState* __tstate = wxPyBeginAllowThreads();
17783 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
17784
17785 wxPyEndAllowThreads(__tstate);
17786 if (PyErr_Occurred()) SWIG_fail;
17787 }
17788 {
17789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17790 }
17791 return resultobj;
17792 fail:
17793 return NULL;
17794 }
17795
17796
17797 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
17798 PyObject *resultobj;
17799 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17800 bool result;
17801 PyObject * obj0 = 0 ;
17802 char *kwnames[] = {
17803 (char *) "self", NULL
17804 };
17805
17806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
17807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17808 if (SWIG_arg_fail(1)) SWIG_fail;
17809 {
17810 PyThreadState* __tstate = wxPyBeginAllowThreads();
17811 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
17812
17813 wxPyEndAllowThreads(__tstate);
17814 if (PyErr_Occurred()) SWIG_fail;
17815 }
17816 {
17817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17818 }
17819 return resultobj;
17820 fail:
17821 return NULL;
17822 }
17823
17824
17825 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
17826 PyObject *resultobj;
17827 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17828 int result;
17829 PyObject * obj0 = 0 ;
17830 char *kwnames[] = {
17831 (char *) "self", NULL
17832 };
17833
17834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
17835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17836 if (SWIG_arg_fail(1)) SWIG_fail;
17837 {
17838 PyThreadState* __tstate = wxPyBeginAllowThreads();
17839 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
17840
17841 wxPyEndAllowThreads(__tstate);
17842 if (PyErr_Occurred()) SWIG_fail;
17843 }
17844 {
17845 resultobj = SWIG_From_int((int)(result));
17846 }
17847 return resultobj;
17848 fail:
17849 return NULL;
17850 }
17851
17852
17853 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
17854 PyObject *resultobj;
17855 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17856 int result;
17857 PyObject * obj0 = 0 ;
17858 char *kwnames[] = {
17859 (char *) "self", NULL
17860 };
17861
17862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
17863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17864 if (SWIG_arg_fail(1)) SWIG_fail;
17865 {
17866 PyThreadState* __tstate = wxPyBeginAllowThreads();
17867 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
17868
17869 wxPyEndAllowThreads(__tstate);
17870 if (PyErr_Occurred()) SWIG_fail;
17871 }
17872 {
17873 resultobj = SWIG_From_int((int)(result));
17874 }
17875 return resultobj;
17876 fail:
17877 return NULL;
17878 }
17879
17880
17881 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
17882 PyObject *resultobj;
17883 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17884 unsigned int result;
17885 PyObject * obj0 = 0 ;
17886 char *kwnames[] = {
17887 (char *) "self", NULL
17888 };
17889
17890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
17891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17892 if (SWIG_arg_fail(1)) SWIG_fail;
17893 {
17894 PyThreadState* __tstate = wxPyBeginAllowThreads();
17895 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
17896
17897 wxPyEndAllowThreads(__tstate);
17898 if (PyErr_Occurred()) SWIG_fail;
17899 }
17900 {
17901 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
17902 }
17903 return resultobj;
17904 fail:
17905 return NULL;
17906 }
17907
17908
17909 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
17910 PyObject *resultobj;
17911 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17912 unsigned int result;
17913 PyObject * obj0 = 0 ;
17914 char *kwnames[] = {
17915 (char *) "self", NULL
17916 };
17917
17918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
17919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17920 if (SWIG_arg_fail(1)) SWIG_fail;
17921 {
17922 PyThreadState* __tstate = wxPyBeginAllowThreads();
17923 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
17924
17925 wxPyEndAllowThreads(__tstate);
17926 if (PyErr_Occurred()) SWIG_fail;
17927 }
17928 {
17929 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
17930 }
17931 return resultobj;
17932 fail:
17933 return NULL;
17934 }
17935
17936
17937 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17938 PyObject *resultobj;
17939 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17940 wxPoint result;
17941 PyObject * obj0 = 0 ;
17942 char *kwnames[] = {
17943 (char *) "self", NULL
17944 };
17945
17946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
17947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17948 if (SWIG_arg_fail(1)) SWIG_fail;
17949 {
17950 PyThreadState* __tstate = wxPyBeginAllowThreads();
17951 result = (arg1)->GetPosition();
17952
17953 wxPyEndAllowThreads(__tstate);
17954 if (PyErr_Occurred()) SWIG_fail;
17955 }
17956 {
17957 wxPoint * resultptr;
17958 resultptr = new wxPoint((wxPoint &)(result));
17959 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17960 }
17961 return resultobj;
17962 fail:
17963 return NULL;
17964 }
17965
17966
17967 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17968 PyObject *resultobj;
17969 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17970 long *arg2 = (long *) 0 ;
17971 long *arg3 = (long *) 0 ;
17972 long temp2 ;
17973 int res2 = 0 ;
17974 long temp3 ;
17975 int res3 = 0 ;
17976 PyObject * obj0 = 0 ;
17977 char *kwnames[] = {
17978 (char *) "self", NULL
17979 };
17980
17981 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17982 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17985 if (SWIG_arg_fail(1)) SWIG_fail;
17986 {
17987 PyThreadState* __tstate = wxPyBeginAllowThreads();
17988 (arg1)->GetPosition(arg2,arg3);
17989
17990 wxPyEndAllowThreads(__tstate);
17991 if (PyErr_Occurred()) SWIG_fail;
17992 }
17993 Py_INCREF(Py_None); resultobj = Py_None;
17994 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17995 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17996 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17997 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17998 return resultobj;
17999 fail:
18000 return NULL;
18001 }
18002
18003
18004 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18005 PyObject *resultobj;
18006 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18007 int result;
18008 PyObject * obj0 = 0 ;
18009 char *kwnames[] = {
18010 (char *) "self", NULL
18011 };
18012
18013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18015 if (SWIG_arg_fail(1)) SWIG_fail;
18016 {
18017 PyThreadState* __tstate = wxPyBeginAllowThreads();
18018 result = (int)((wxKeyEvent const *)arg1)->GetX();
18019
18020 wxPyEndAllowThreads(__tstate);
18021 if (PyErr_Occurred()) SWIG_fail;
18022 }
18023 {
18024 resultobj = SWIG_From_int((int)(result));
18025 }
18026 return resultobj;
18027 fail:
18028 return NULL;
18029 }
18030
18031
18032 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18033 PyObject *resultobj;
18034 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18035 int result;
18036 PyObject * obj0 = 0 ;
18037 char *kwnames[] = {
18038 (char *) "self", NULL
18039 };
18040
18041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18043 if (SWIG_arg_fail(1)) SWIG_fail;
18044 {
18045 PyThreadState* __tstate = wxPyBeginAllowThreads();
18046 result = (int)((wxKeyEvent const *)arg1)->GetY();
18047
18048 wxPyEndAllowThreads(__tstate);
18049 if (PyErr_Occurred()) SWIG_fail;
18050 }
18051 {
18052 resultobj = SWIG_From_int((int)(result));
18053 }
18054 return resultobj;
18055 fail:
18056 return NULL;
18057 }
18058
18059
18060 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18061 PyObject *resultobj;
18062 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18063 int arg2 ;
18064 PyObject * obj0 = 0 ;
18065 PyObject * obj1 = 0 ;
18066 char *kwnames[] = {
18067 (char *) "self",(char *) "m_x", NULL
18068 };
18069
18070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18072 if (SWIG_arg_fail(1)) SWIG_fail;
18073 {
18074 arg2 = (int)(SWIG_As_int(obj1));
18075 if (SWIG_arg_fail(2)) SWIG_fail;
18076 }
18077 if (arg1) (arg1)->m_x = arg2;
18078
18079 Py_INCREF(Py_None); resultobj = Py_None;
18080 return resultobj;
18081 fail:
18082 return NULL;
18083 }
18084
18085
18086 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18087 PyObject *resultobj;
18088 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18089 int result;
18090 PyObject * obj0 = 0 ;
18091 char *kwnames[] = {
18092 (char *) "self", NULL
18093 };
18094
18095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18097 if (SWIG_arg_fail(1)) SWIG_fail;
18098 result = (int) ((arg1)->m_x);
18099
18100 {
18101 resultobj = SWIG_From_int((int)(result));
18102 }
18103 return resultobj;
18104 fail:
18105 return NULL;
18106 }
18107
18108
18109 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18110 PyObject *resultobj;
18111 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18112 int arg2 ;
18113 PyObject * obj0 = 0 ;
18114 PyObject * obj1 = 0 ;
18115 char *kwnames[] = {
18116 (char *) "self",(char *) "m_y", NULL
18117 };
18118
18119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18121 if (SWIG_arg_fail(1)) SWIG_fail;
18122 {
18123 arg2 = (int)(SWIG_As_int(obj1));
18124 if (SWIG_arg_fail(2)) SWIG_fail;
18125 }
18126 if (arg1) (arg1)->m_y = arg2;
18127
18128 Py_INCREF(Py_None); resultobj = Py_None;
18129 return resultobj;
18130 fail:
18131 return NULL;
18132 }
18133
18134
18135 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18136 PyObject *resultobj;
18137 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18138 int result;
18139 PyObject * obj0 = 0 ;
18140 char *kwnames[] = {
18141 (char *) "self", NULL
18142 };
18143
18144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18146 if (SWIG_arg_fail(1)) SWIG_fail;
18147 result = (int) ((arg1)->m_y);
18148
18149 {
18150 resultobj = SWIG_From_int((int)(result));
18151 }
18152 return resultobj;
18153 fail:
18154 return NULL;
18155 }
18156
18157
18158 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18159 PyObject *resultobj;
18160 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18161 long arg2 ;
18162 PyObject * obj0 = 0 ;
18163 PyObject * obj1 = 0 ;
18164 char *kwnames[] = {
18165 (char *) "self",(char *) "m_keyCode", NULL
18166 };
18167
18168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18170 if (SWIG_arg_fail(1)) SWIG_fail;
18171 {
18172 arg2 = (long)(SWIG_As_long(obj1));
18173 if (SWIG_arg_fail(2)) SWIG_fail;
18174 }
18175 if (arg1) (arg1)->m_keyCode = arg2;
18176
18177 Py_INCREF(Py_None); resultobj = Py_None;
18178 return resultobj;
18179 fail:
18180 return NULL;
18181 }
18182
18183
18184 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18185 PyObject *resultobj;
18186 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18187 long result;
18188 PyObject * obj0 = 0 ;
18189 char *kwnames[] = {
18190 (char *) "self", NULL
18191 };
18192
18193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18195 if (SWIG_arg_fail(1)) SWIG_fail;
18196 result = (long) ((arg1)->m_keyCode);
18197
18198 {
18199 resultobj = SWIG_From_long((long)(result));
18200 }
18201 return resultobj;
18202 fail:
18203 return NULL;
18204 }
18205
18206
18207 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18208 PyObject *resultobj;
18209 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18210 bool arg2 ;
18211 PyObject * obj0 = 0 ;
18212 PyObject * obj1 = 0 ;
18213 char *kwnames[] = {
18214 (char *) "self",(char *) "m_controlDown", NULL
18215 };
18216
18217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18219 if (SWIG_arg_fail(1)) SWIG_fail;
18220 {
18221 arg2 = (bool)(SWIG_As_bool(obj1));
18222 if (SWIG_arg_fail(2)) SWIG_fail;
18223 }
18224 if (arg1) (arg1)->m_controlDown = arg2;
18225
18226 Py_INCREF(Py_None); resultobj = Py_None;
18227 return resultobj;
18228 fail:
18229 return NULL;
18230 }
18231
18232
18233 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18234 PyObject *resultobj;
18235 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18236 bool result;
18237 PyObject * obj0 = 0 ;
18238 char *kwnames[] = {
18239 (char *) "self", NULL
18240 };
18241
18242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18244 if (SWIG_arg_fail(1)) SWIG_fail;
18245 result = (bool) ((arg1)->m_controlDown);
18246
18247 {
18248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18249 }
18250 return resultobj;
18251 fail:
18252 return NULL;
18253 }
18254
18255
18256 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18257 PyObject *resultobj;
18258 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18259 bool arg2 ;
18260 PyObject * obj0 = 0 ;
18261 PyObject * obj1 = 0 ;
18262 char *kwnames[] = {
18263 (char *) "self",(char *) "m_shiftDown", NULL
18264 };
18265
18266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18268 if (SWIG_arg_fail(1)) SWIG_fail;
18269 {
18270 arg2 = (bool)(SWIG_As_bool(obj1));
18271 if (SWIG_arg_fail(2)) SWIG_fail;
18272 }
18273 if (arg1) (arg1)->m_shiftDown = arg2;
18274
18275 Py_INCREF(Py_None); resultobj = Py_None;
18276 return resultobj;
18277 fail:
18278 return NULL;
18279 }
18280
18281
18282 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18283 PyObject *resultobj;
18284 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18285 bool result;
18286 PyObject * obj0 = 0 ;
18287 char *kwnames[] = {
18288 (char *) "self", NULL
18289 };
18290
18291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18293 if (SWIG_arg_fail(1)) SWIG_fail;
18294 result = (bool) ((arg1)->m_shiftDown);
18295
18296 {
18297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18298 }
18299 return resultobj;
18300 fail:
18301 return NULL;
18302 }
18303
18304
18305 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18306 PyObject *resultobj;
18307 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18308 bool arg2 ;
18309 PyObject * obj0 = 0 ;
18310 PyObject * obj1 = 0 ;
18311 char *kwnames[] = {
18312 (char *) "self",(char *) "m_altDown", NULL
18313 };
18314
18315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18317 if (SWIG_arg_fail(1)) SWIG_fail;
18318 {
18319 arg2 = (bool)(SWIG_As_bool(obj1));
18320 if (SWIG_arg_fail(2)) SWIG_fail;
18321 }
18322 if (arg1) (arg1)->m_altDown = arg2;
18323
18324 Py_INCREF(Py_None); resultobj = Py_None;
18325 return resultobj;
18326 fail:
18327 return NULL;
18328 }
18329
18330
18331 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18332 PyObject *resultobj;
18333 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18334 bool result;
18335 PyObject * obj0 = 0 ;
18336 char *kwnames[] = {
18337 (char *) "self", NULL
18338 };
18339
18340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18342 if (SWIG_arg_fail(1)) SWIG_fail;
18343 result = (bool) ((arg1)->m_altDown);
18344
18345 {
18346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18347 }
18348 return resultobj;
18349 fail:
18350 return NULL;
18351 }
18352
18353
18354 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18355 PyObject *resultobj;
18356 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18357 bool arg2 ;
18358 PyObject * obj0 = 0 ;
18359 PyObject * obj1 = 0 ;
18360 char *kwnames[] = {
18361 (char *) "self",(char *) "m_metaDown", NULL
18362 };
18363
18364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18366 if (SWIG_arg_fail(1)) SWIG_fail;
18367 {
18368 arg2 = (bool)(SWIG_As_bool(obj1));
18369 if (SWIG_arg_fail(2)) SWIG_fail;
18370 }
18371 if (arg1) (arg1)->m_metaDown = arg2;
18372
18373 Py_INCREF(Py_None); resultobj = Py_None;
18374 return resultobj;
18375 fail:
18376 return NULL;
18377 }
18378
18379
18380 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18381 PyObject *resultobj;
18382 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18383 bool result;
18384 PyObject * obj0 = 0 ;
18385 char *kwnames[] = {
18386 (char *) "self", NULL
18387 };
18388
18389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18391 if (SWIG_arg_fail(1)) SWIG_fail;
18392 result = (bool) ((arg1)->m_metaDown);
18393
18394 {
18395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18396 }
18397 return resultobj;
18398 fail:
18399 return NULL;
18400 }
18401
18402
18403 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18404 PyObject *resultobj;
18405 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18406 bool arg2 ;
18407 PyObject * obj0 = 0 ;
18408 PyObject * obj1 = 0 ;
18409 char *kwnames[] = {
18410 (char *) "self",(char *) "m_scanCode", NULL
18411 };
18412
18413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18415 if (SWIG_arg_fail(1)) SWIG_fail;
18416 {
18417 arg2 = (bool)(SWIG_As_bool(obj1));
18418 if (SWIG_arg_fail(2)) SWIG_fail;
18419 }
18420 if (arg1) (arg1)->m_scanCode = arg2;
18421
18422 Py_INCREF(Py_None); resultobj = Py_None;
18423 return resultobj;
18424 fail:
18425 return NULL;
18426 }
18427
18428
18429 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18430 PyObject *resultobj;
18431 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18432 bool result;
18433 PyObject * obj0 = 0 ;
18434 char *kwnames[] = {
18435 (char *) "self", NULL
18436 };
18437
18438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18440 if (SWIG_arg_fail(1)) SWIG_fail;
18441 result = (bool) ((arg1)->m_scanCode);
18442
18443 {
18444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18445 }
18446 return resultobj;
18447 fail:
18448 return NULL;
18449 }
18450
18451
18452 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18453 PyObject *resultobj;
18454 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18455 unsigned int arg2 ;
18456 PyObject * obj0 = 0 ;
18457 PyObject * obj1 = 0 ;
18458 char *kwnames[] = {
18459 (char *) "self",(char *) "m_rawCode", NULL
18460 };
18461
18462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18464 if (SWIG_arg_fail(1)) SWIG_fail;
18465 {
18466 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18467 if (SWIG_arg_fail(2)) SWIG_fail;
18468 }
18469 if (arg1) (arg1)->m_rawCode = arg2;
18470
18471 Py_INCREF(Py_None); resultobj = Py_None;
18472 return resultobj;
18473 fail:
18474 return NULL;
18475 }
18476
18477
18478 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18479 PyObject *resultobj;
18480 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18481 unsigned int result;
18482 PyObject * obj0 = 0 ;
18483 char *kwnames[] = {
18484 (char *) "self", NULL
18485 };
18486
18487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18489 if (SWIG_arg_fail(1)) SWIG_fail;
18490 result = (unsigned int) ((arg1)->m_rawCode);
18491
18492 {
18493 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18494 }
18495 return resultobj;
18496 fail:
18497 return NULL;
18498 }
18499
18500
18501 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18502 PyObject *resultobj;
18503 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18504 unsigned int arg2 ;
18505 PyObject * obj0 = 0 ;
18506 PyObject * obj1 = 0 ;
18507 char *kwnames[] = {
18508 (char *) "self",(char *) "m_rawFlags", NULL
18509 };
18510
18511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18513 if (SWIG_arg_fail(1)) SWIG_fail;
18514 {
18515 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18516 if (SWIG_arg_fail(2)) SWIG_fail;
18517 }
18518 if (arg1) (arg1)->m_rawFlags = arg2;
18519
18520 Py_INCREF(Py_None); resultobj = Py_None;
18521 return resultobj;
18522 fail:
18523 return NULL;
18524 }
18525
18526
18527 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
18528 PyObject *resultobj;
18529 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18530 unsigned int result;
18531 PyObject * obj0 = 0 ;
18532 char *kwnames[] = {
18533 (char *) "self", NULL
18534 };
18535
18536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
18537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18538 if (SWIG_arg_fail(1)) SWIG_fail;
18539 result = (unsigned int) ((arg1)->m_rawFlags);
18540
18541 {
18542 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18543 }
18544 return resultobj;
18545 fail:
18546 return NULL;
18547 }
18548
18549
18550 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
18551 PyObject *obj;
18552 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18553 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
18554 Py_INCREF(obj);
18555 return Py_BuildValue((char *)"");
18556 }
18557 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18558 PyObject *resultobj;
18559 wxSize const &arg1_defvalue = wxDefaultSize ;
18560 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
18561 int arg2 = (int) 0 ;
18562 wxSizeEvent *result;
18563 wxSize temp1 ;
18564 PyObject * obj0 = 0 ;
18565 PyObject * obj1 = 0 ;
18566 char *kwnames[] = {
18567 (char *) "sz",(char *) "winid", NULL
18568 };
18569
18570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
18571 if (obj0) {
18572 {
18573 arg1 = &temp1;
18574 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
18575 }
18576 }
18577 if (obj1) {
18578 {
18579 arg2 = (int)(SWIG_As_int(obj1));
18580 if (SWIG_arg_fail(2)) SWIG_fail;
18581 }
18582 }
18583 {
18584 PyThreadState* __tstate = wxPyBeginAllowThreads();
18585 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
18586
18587 wxPyEndAllowThreads(__tstate);
18588 if (PyErr_Occurred()) SWIG_fail;
18589 }
18590 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
18591 return resultobj;
18592 fail:
18593 return NULL;
18594 }
18595
18596
18597 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18598 PyObject *resultobj;
18599 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18600 wxSize result;
18601 PyObject * obj0 = 0 ;
18602 char *kwnames[] = {
18603 (char *) "self", NULL
18604 };
18605
18606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
18607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18608 if (SWIG_arg_fail(1)) SWIG_fail;
18609 {
18610 PyThreadState* __tstate = wxPyBeginAllowThreads();
18611 result = ((wxSizeEvent const *)arg1)->GetSize();
18612
18613 wxPyEndAllowThreads(__tstate);
18614 if (PyErr_Occurred()) SWIG_fail;
18615 }
18616 {
18617 wxSize * resultptr;
18618 resultptr = new wxSize((wxSize &)(result));
18619 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18620 }
18621 return resultobj;
18622 fail:
18623 return NULL;
18624 }
18625
18626
18627 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18628 PyObject *resultobj;
18629 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18630 wxRect result;
18631 PyObject * obj0 = 0 ;
18632 char *kwnames[] = {
18633 (char *) "self", NULL
18634 };
18635
18636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
18637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18638 if (SWIG_arg_fail(1)) SWIG_fail;
18639 {
18640 PyThreadState* __tstate = wxPyBeginAllowThreads();
18641 result = ((wxSizeEvent const *)arg1)->GetRect();
18642
18643 wxPyEndAllowThreads(__tstate);
18644 if (PyErr_Occurred()) SWIG_fail;
18645 }
18646 {
18647 wxRect * resultptr;
18648 resultptr = new wxRect((wxRect &)(result));
18649 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18650 }
18651 return resultobj;
18652 fail:
18653 return NULL;
18654 }
18655
18656
18657 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18658 PyObject *resultobj;
18659 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18660 wxRect arg2 ;
18661 PyObject * obj0 = 0 ;
18662 PyObject * obj1 = 0 ;
18663 char *kwnames[] = {
18664 (char *) "self",(char *) "rect", NULL
18665 };
18666
18667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18669 if (SWIG_arg_fail(1)) SWIG_fail;
18670 {
18671 wxRect * argp;
18672 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18673 if (SWIG_arg_fail(2)) SWIG_fail;
18674 if (argp == NULL) {
18675 SWIG_null_ref("wxRect");
18676 }
18677 if (SWIG_arg_fail(2)) SWIG_fail;
18678 arg2 = *argp;
18679 }
18680 {
18681 PyThreadState* __tstate = wxPyBeginAllowThreads();
18682 (arg1)->SetRect(arg2);
18683
18684 wxPyEndAllowThreads(__tstate);
18685 if (PyErr_Occurred()) SWIG_fail;
18686 }
18687 Py_INCREF(Py_None); resultobj = Py_None;
18688 return resultobj;
18689 fail:
18690 return NULL;
18691 }
18692
18693
18694 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18695 PyObject *resultobj;
18696 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18697 wxSize arg2 ;
18698 PyObject * obj0 = 0 ;
18699 PyObject * obj1 = 0 ;
18700 char *kwnames[] = {
18701 (char *) "self",(char *) "size", NULL
18702 };
18703
18704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
18705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18706 if (SWIG_arg_fail(1)) SWIG_fail;
18707 {
18708 wxSize * argp;
18709 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
18710 if (SWIG_arg_fail(2)) SWIG_fail;
18711 if (argp == NULL) {
18712 SWIG_null_ref("wxSize");
18713 }
18714 if (SWIG_arg_fail(2)) SWIG_fail;
18715 arg2 = *argp;
18716 }
18717 {
18718 PyThreadState* __tstate = wxPyBeginAllowThreads();
18719 wxSizeEvent_SetSize(arg1,arg2);
18720
18721 wxPyEndAllowThreads(__tstate);
18722 if (PyErr_Occurred()) SWIG_fail;
18723 }
18724 Py_INCREF(Py_None); resultobj = Py_None;
18725 return resultobj;
18726 fail:
18727 return NULL;
18728 }
18729
18730
18731 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
18732 PyObject *resultobj;
18733 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18734 wxSize *arg2 = (wxSize *) 0 ;
18735 PyObject * obj0 = 0 ;
18736 PyObject * obj1 = 0 ;
18737 char *kwnames[] = {
18738 (char *) "self",(char *) "m_size", NULL
18739 };
18740
18741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
18742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18743 if (SWIG_arg_fail(1)) SWIG_fail;
18744 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
18745 if (SWIG_arg_fail(2)) SWIG_fail;
18746 if (arg1) (arg1)->m_size = *arg2;
18747
18748 Py_INCREF(Py_None); resultobj = Py_None;
18749 return resultobj;
18750 fail:
18751 return NULL;
18752 }
18753
18754
18755 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
18756 PyObject *resultobj;
18757 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18758 wxSize *result;
18759 PyObject * obj0 = 0 ;
18760 char *kwnames[] = {
18761 (char *) "self", NULL
18762 };
18763
18764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
18765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18766 if (SWIG_arg_fail(1)) SWIG_fail;
18767 result = (wxSize *)& ((arg1)->m_size);
18768
18769 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
18770 return resultobj;
18771 fail:
18772 return NULL;
18773 }
18774
18775
18776 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
18777 PyObject *resultobj;
18778 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18779 wxRect *arg2 = (wxRect *) 0 ;
18780 PyObject * obj0 = 0 ;
18781 PyObject * obj1 = 0 ;
18782 char *kwnames[] = {
18783 (char *) "self",(char *) "m_rect", NULL
18784 };
18785
18786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
18787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18788 if (SWIG_arg_fail(1)) SWIG_fail;
18789 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18790 if (SWIG_arg_fail(2)) SWIG_fail;
18791 if (arg1) (arg1)->m_rect = *arg2;
18792
18793 Py_INCREF(Py_None); resultobj = Py_None;
18794 return resultobj;
18795 fail:
18796 return NULL;
18797 }
18798
18799
18800 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
18801 PyObject *resultobj;
18802 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18803 wxRect *result;
18804 PyObject * obj0 = 0 ;
18805 char *kwnames[] = {
18806 (char *) "self", NULL
18807 };
18808
18809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
18810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18811 if (SWIG_arg_fail(1)) SWIG_fail;
18812 result = (wxRect *)& ((arg1)->m_rect);
18813
18814 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
18815 return resultobj;
18816 fail:
18817 return NULL;
18818 }
18819
18820
18821 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
18822 PyObject *obj;
18823 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18824 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
18825 Py_INCREF(obj);
18826 return Py_BuildValue((char *)"");
18827 }
18828 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18829 PyObject *resultobj;
18830 wxPoint const &arg1_defvalue = wxDefaultPosition ;
18831 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
18832 int arg2 = (int) 0 ;
18833 wxMoveEvent *result;
18834 wxPoint temp1 ;
18835 PyObject * obj0 = 0 ;
18836 PyObject * obj1 = 0 ;
18837 char *kwnames[] = {
18838 (char *) "pos",(char *) "winid", NULL
18839 };
18840
18841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
18842 if (obj0) {
18843 {
18844 arg1 = &temp1;
18845 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
18846 }
18847 }
18848 if (obj1) {
18849 {
18850 arg2 = (int)(SWIG_As_int(obj1));
18851 if (SWIG_arg_fail(2)) SWIG_fail;
18852 }
18853 }
18854 {
18855 PyThreadState* __tstate = wxPyBeginAllowThreads();
18856 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
18857
18858 wxPyEndAllowThreads(__tstate);
18859 if (PyErr_Occurred()) SWIG_fail;
18860 }
18861 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
18862 return resultobj;
18863 fail:
18864 return NULL;
18865 }
18866
18867
18868 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18869 PyObject *resultobj;
18870 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18871 wxPoint result;
18872 PyObject * obj0 = 0 ;
18873 char *kwnames[] = {
18874 (char *) "self", NULL
18875 };
18876
18877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
18878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18879 if (SWIG_arg_fail(1)) SWIG_fail;
18880 {
18881 PyThreadState* __tstate = wxPyBeginAllowThreads();
18882 result = ((wxMoveEvent const *)arg1)->GetPosition();
18883
18884 wxPyEndAllowThreads(__tstate);
18885 if (PyErr_Occurred()) SWIG_fail;
18886 }
18887 {
18888 wxPoint * resultptr;
18889 resultptr = new wxPoint((wxPoint &)(result));
18890 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18891 }
18892 return resultobj;
18893 fail:
18894 return NULL;
18895 }
18896
18897
18898 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18899 PyObject *resultobj;
18900 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18901 wxRect result;
18902 PyObject * obj0 = 0 ;
18903 char *kwnames[] = {
18904 (char *) "self", NULL
18905 };
18906
18907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
18908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18909 if (SWIG_arg_fail(1)) SWIG_fail;
18910 {
18911 PyThreadState* __tstate = wxPyBeginAllowThreads();
18912 result = ((wxMoveEvent const *)arg1)->GetRect();
18913
18914 wxPyEndAllowThreads(__tstate);
18915 if (PyErr_Occurred()) SWIG_fail;
18916 }
18917 {
18918 wxRect * resultptr;
18919 resultptr = new wxRect((wxRect &)(result));
18920 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18921 }
18922 return resultobj;
18923 fail:
18924 return NULL;
18925 }
18926
18927
18928 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18929 PyObject *resultobj;
18930 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18931 wxRect arg2 ;
18932 PyObject * obj0 = 0 ;
18933 PyObject * obj1 = 0 ;
18934 char *kwnames[] = {
18935 (char *) "self",(char *) "rect", NULL
18936 };
18937
18938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18940 if (SWIG_arg_fail(1)) SWIG_fail;
18941 {
18942 wxRect * argp;
18943 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18944 if (SWIG_arg_fail(2)) SWIG_fail;
18945 if (argp == NULL) {
18946 SWIG_null_ref("wxRect");
18947 }
18948 if (SWIG_arg_fail(2)) SWIG_fail;
18949 arg2 = *argp;
18950 }
18951 {
18952 PyThreadState* __tstate = wxPyBeginAllowThreads();
18953 (arg1)->SetRect(arg2);
18954
18955 wxPyEndAllowThreads(__tstate);
18956 if (PyErr_Occurred()) SWIG_fail;
18957 }
18958 Py_INCREF(Py_None); resultobj = Py_None;
18959 return resultobj;
18960 fail:
18961 return NULL;
18962 }
18963
18964
18965 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18966 PyObject *resultobj;
18967 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18968 wxPoint arg2 ;
18969 PyObject * obj0 = 0 ;
18970 PyObject * obj1 = 0 ;
18971 char *kwnames[] = {
18972 (char *) "self",(char *) "pos", NULL
18973 };
18974
18975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
18976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18977 if (SWIG_arg_fail(1)) SWIG_fail;
18978 {
18979 wxPoint * argp;
18980 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
18981 if (SWIG_arg_fail(2)) SWIG_fail;
18982 if (argp == NULL) {
18983 SWIG_null_ref("wxPoint");
18984 }
18985 if (SWIG_arg_fail(2)) SWIG_fail;
18986 arg2 = *argp;
18987 }
18988 {
18989 PyThreadState* __tstate = wxPyBeginAllowThreads();
18990 wxMoveEvent_SetPosition(arg1,arg2);
18991
18992 wxPyEndAllowThreads(__tstate);
18993 if (PyErr_Occurred()) SWIG_fail;
18994 }
18995 Py_INCREF(Py_None); resultobj = Py_None;
18996 return resultobj;
18997 fail:
18998 return NULL;
18999 }
19000
19001
19002 static PyObject *_wrap_MoveEvent_m_pos_set(PyObject *, PyObject *args, PyObject *kwargs) {
19003 PyObject *resultobj;
19004 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19005 wxPoint *arg2 = (wxPoint *) 0 ;
19006 PyObject * obj0 = 0 ;
19007 PyObject * obj1 = 0 ;
19008 char *kwnames[] = {
19009 (char *) "self",(char *) "m_pos", NULL
19010 };
19011
19012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_m_pos_set",kwnames,&obj0,&obj1)) goto fail;
19013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19014 if (SWIG_arg_fail(1)) SWIG_fail;
19015 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
19016 if (SWIG_arg_fail(2)) SWIG_fail;
19017 if (arg1) (arg1)->m_pos = *arg2;
19018
19019 Py_INCREF(Py_None); resultobj = Py_None;
19020 return resultobj;
19021 fail:
19022 return NULL;
19023 }
19024
19025
19026 static PyObject *_wrap_MoveEvent_m_pos_get(PyObject *, PyObject *args, PyObject *kwargs) {
19027 PyObject *resultobj;
19028 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19029 wxPoint *result;
19030 PyObject * obj0 = 0 ;
19031 char *kwnames[] = {
19032 (char *) "self", NULL
19033 };
19034
19035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_m_pos_get",kwnames,&obj0)) goto fail;
19036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19037 if (SWIG_arg_fail(1)) SWIG_fail;
19038 result = (wxPoint *)& ((arg1)->m_pos);
19039
19040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
19041 return resultobj;
19042 fail:
19043 return NULL;
19044 }
19045
19046
19047 static PyObject *_wrap_MoveEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19048 PyObject *resultobj;
19049 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19050 wxRect *arg2 = (wxRect *) 0 ;
19051 PyObject * obj0 = 0 ;
19052 PyObject * obj1 = 0 ;
19053 char *kwnames[] = {
19054 (char *) "self",(char *) "m_rect", NULL
19055 };
19056
19057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19059 if (SWIG_arg_fail(1)) SWIG_fail;
19060 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19061 if (SWIG_arg_fail(2)) SWIG_fail;
19062 if (arg1) (arg1)->m_rect = *arg2;
19063
19064 Py_INCREF(Py_None); resultobj = Py_None;
19065 return resultobj;
19066 fail:
19067 return NULL;
19068 }
19069
19070
19071 static PyObject *_wrap_MoveEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19072 PyObject *resultobj;
19073 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19074 wxRect *result;
19075 PyObject * obj0 = 0 ;
19076 char *kwnames[] = {
19077 (char *) "self", NULL
19078 };
19079
19080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_m_rect_get",kwnames,&obj0)) goto fail;
19081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19082 if (SWIG_arg_fail(1)) SWIG_fail;
19083 result = (wxRect *)& ((arg1)->m_rect);
19084
19085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19086 return resultobj;
19087 fail:
19088 return NULL;
19089 }
19090
19091
19092 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19093 PyObject *obj;
19094 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19095 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19096 Py_INCREF(obj);
19097 return Py_BuildValue((char *)"");
19098 }
19099 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19100 PyObject *resultobj;
19101 int arg1 = (int) 0 ;
19102 wxPaintEvent *result;
19103 PyObject * obj0 = 0 ;
19104 char *kwnames[] = {
19105 (char *) "Id", NULL
19106 };
19107
19108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19109 if (obj0) {
19110 {
19111 arg1 = (int)(SWIG_As_int(obj0));
19112 if (SWIG_arg_fail(1)) SWIG_fail;
19113 }
19114 }
19115 {
19116 PyThreadState* __tstate = wxPyBeginAllowThreads();
19117 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19118
19119 wxPyEndAllowThreads(__tstate);
19120 if (PyErr_Occurred()) SWIG_fail;
19121 }
19122 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19123 return resultobj;
19124 fail:
19125 return NULL;
19126 }
19127
19128
19129 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19130 PyObject *obj;
19131 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19132 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19133 Py_INCREF(obj);
19134 return Py_BuildValue((char *)"");
19135 }
19136 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19137 PyObject *resultobj;
19138 int arg1 = (int) 0 ;
19139 wxNcPaintEvent *result;
19140 PyObject * obj0 = 0 ;
19141 char *kwnames[] = {
19142 (char *) "winid", NULL
19143 };
19144
19145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19146 if (obj0) {
19147 {
19148 arg1 = (int)(SWIG_As_int(obj0));
19149 if (SWIG_arg_fail(1)) SWIG_fail;
19150 }
19151 }
19152 {
19153 PyThreadState* __tstate = wxPyBeginAllowThreads();
19154 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19155
19156 wxPyEndAllowThreads(__tstate);
19157 if (PyErr_Occurred()) SWIG_fail;
19158 }
19159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19160 return resultobj;
19161 fail:
19162 return NULL;
19163 }
19164
19165
19166 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19167 PyObject *obj;
19168 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19169 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19170 Py_INCREF(obj);
19171 return Py_BuildValue((char *)"");
19172 }
19173 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19174 PyObject *resultobj;
19175 int arg1 = (int) 0 ;
19176 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19177 wxEraseEvent *result;
19178 PyObject * obj0 = 0 ;
19179 PyObject * obj1 = 0 ;
19180 char *kwnames[] = {
19181 (char *) "Id",(char *) "dc", NULL
19182 };
19183
19184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19185 if (obj0) {
19186 {
19187 arg1 = (int)(SWIG_As_int(obj0));
19188 if (SWIG_arg_fail(1)) SWIG_fail;
19189 }
19190 }
19191 if (obj1) {
19192 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19193 if (SWIG_arg_fail(2)) SWIG_fail;
19194 }
19195 {
19196 PyThreadState* __tstate = wxPyBeginAllowThreads();
19197 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19198
19199 wxPyEndAllowThreads(__tstate);
19200 if (PyErr_Occurred()) SWIG_fail;
19201 }
19202 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19203 return resultobj;
19204 fail:
19205 return NULL;
19206 }
19207
19208
19209 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19210 PyObject *resultobj;
19211 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19212 wxDC *result;
19213 PyObject * obj0 = 0 ;
19214 char *kwnames[] = {
19215 (char *) "self", NULL
19216 };
19217
19218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19220 if (SWIG_arg_fail(1)) SWIG_fail;
19221 {
19222 PyThreadState* __tstate = wxPyBeginAllowThreads();
19223 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19224
19225 wxPyEndAllowThreads(__tstate);
19226 if (PyErr_Occurred()) SWIG_fail;
19227 }
19228 {
19229 resultobj = wxPyMake_wxObject(result, 0);
19230 }
19231 return resultobj;
19232 fail:
19233 return NULL;
19234 }
19235
19236
19237 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19238 PyObject *obj;
19239 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19240 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19241 Py_INCREF(obj);
19242 return Py_BuildValue((char *)"");
19243 }
19244 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19245 PyObject *resultobj;
19246 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19247 int arg2 = (int) 0 ;
19248 wxFocusEvent *result;
19249 PyObject * obj0 = 0 ;
19250 PyObject * obj1 = 0 ;
19251 char *kwnames[] = {
19252 (char *) "type",(char *) "winid", NULL
19253 };
19254
19255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19256 if (obj0) {
19257 {
19258 arg1 = (wxEventType)(SWIG_As_int(obj0));
19259 if (SWIG_arg_fail(1)) SWIG_fail;
19260 }
19261 }
19262 if (obj1) {
19263 {
19264 arg2 = (int)(SWIG_As_int(obj1));
19265 if (SWIG_arg_fail(2)) SWIG_fail;
19266 }
19267 }
19268 {
19269 PyThreadState* __tstate = wxPyBeginAllowThreads();
19270 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19271
19272 wxPyEndAllowThreads(__tstate);
19273 if (PyErr_Occurred()) SWIG_fail;
19274 }
19275 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19276 return resultobj;
19277 fail:
19278 return NULL;
19279 }
19280
19281
19282 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19283 PyObject *resultobj;
19284 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19285 wxWindow *result;
19286 PyObject * obj0 = 0 ;
19287 char *kwnames[] = {
19288 (char *) "self", NULL
19289 };
19290
19291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19293 if (SWIG_arg_fail(1)) SWIG_fail;
19294 {
19295 PyThreadState* __tstate = wxPyBeginAllowThreads();
19296 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19297
19298 wxPyEndAllowThreads(__tstate);
19299 if (PyErr_Occurred()) SWIG_fail;
19300 }
19301 {
19302 resultobj = wxPyMake_wxObject(result, 0);
19303 }
19304 return resultobj;
19305 fail:
19306 return NULL;
19307 }
19308
19309
19310 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19311 PyObject *resultobj;
19312 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19313 wxWindow *arg2 = (wxWindow *) 0 ;
19314 PyObject * obj0 = 0 ;
19315 PyObject * obj1 = 0 ;
19316 char *kwnames[] = {
19317 (char *) "self",(char *) "win", NULL
19318 };
19319
19320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19322 if (SWIG_arg_fail(1)) SWIG_fail;
19323 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19324 if (SWIG_arg_fail(2)) SWIG_fail;
19325 {
19326 PyThreadState* __tstate = wxPyBeginAllowThreads();
19327 (arg1)->SetWindow(arg2);
19328
19329 wxPyEndAllowThreads(__tstate);
19330 if (PyErr_Occurred()) SWIG_fail;
19331 }
19332 Py_INCREF(Py_None); resultobj = Py_None;
19333 return resultobj;
19334 fail:
19335 return NULL;
19336 }
19337
19338
19339 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19340 PyObject *obj;
19341 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19342 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19343 Py_INCREF(obj);
19344 return Py_BuildValue((char *)"");
19345 }
19346 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19347 PyObject *resultobj;
19348 wxWindow *arg1 = (wxWindow *) NULL ;
19349 wxChildFocusEvent *result;
19350 PyObject * obj0 = 0 ;
19351 char *kwnames[] = {
19352 (char *) "win", NULL
19353 };
19354
19355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19356 if (obj0) {
19357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19358 if (SWIG_arg_fail(1)) SWIG_fail;
19359 }
19360 {
19361 PyThreadState* __tstate = wxPyBeginAllowThreads();
19362 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19363
19364 wxPyEndAllowThreads(__tstate);
19365 if (PyErr_Occurred()) SWIG_fail;
19366 }
19367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19368 return resultobj;
19369 fail:
19370 return NULL;
19371 }
19372
19373
19374 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19375 PyObject *resultobj;
19376 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19377 wxWindow *result;
19378 PyObject * obj0 = 0 ;
19379 char *kwnames[] = {
19380 (char *) "self", NULL
19381 };
19382
19383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19385 if (SWIG_arg_fail(1)) SWIG_fail;
19386 {
19387 PyThreadState* __tstate = wxPyBeginAllowThreads();
19388 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19389
19390 wxPyEndAllowThreads(__tstate);
19391 if (PyErr_Occurred()) SWIG_fail;
19392 }
19393 {
19394 resultobj = wxPyMake_wxObject(result, 0);
19395 }
19396 return resultobj;
19397 fail:
19398 return NULL;
19399 }
19400
19401
19402 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19403 PyObject *obj;
19404 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19405 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19406 Py_INCREF(obj);
19407 return Py_BuildValue((char *)"");
19408 }
19409 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19410 PyObject *resultobj;
19411 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19412 bool arg2 = (bool) true ;
19413 int arg3 = (int) 0 ;
19414 wxActivateEvent *result;
19415 PyObject * obj0 = 0 ;
19416 PyObject * obj1 = 0 ;
19417 PyObject * obj2 = 0 ;
19418 char *kwnames[] = {
19419 (char *) "type",(char *) "active",(char *) "Id", NULL
19420 };
19421
19422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19423 if (obj0) {
19424 {
19425 arg1 = (wxEventType)(SWIG_As_int(obj0));
19426 if (SWIG_arg_fail(1)) SWIG_fail;
19427 }
19428 }
19429 if (obj1) {
19430 {
19431 arg2 = (bool)(SWIG_As_bool(obj1));
19432 if (SWIG_arg_fail(2)) SWIG_fail;
19433 }
19434 }
19435 if (obj2) {
19436 {
19437 arg3 = (int)(SWIG_As_int(obj2));
19438 if (SWIG_arg_fail(3)) SWIG_fail;
19439 }
19440 }
19441 {
19442 PyThreadState* __tstate = wxPyBeginAllowThreads();
19443 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19444
19445 wxPyEndAllowThreads(__tstate);
19446 if (PyErr_Occurred()) SWIG_fail;
19447 }
19448 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19449 return resultobj;
19450 fail:
19451 return NULL;
19452 }
19453
19454
19455 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19456 PyObject *resultobj;
19457 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19458 bool result;
19459 PyObject * obj0 = 0 ;
19460 char *kwnames[] = {
19461 (char *) "self", NULL
19462 };
19463
19464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19466 if (SWIG_arg_fail(1)) SWIG_fail;
19467 {
19468 PyThreadState* __tstate = wxPyBeginAllowThreads();
19469 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19470
19471 wxPyEndAllowThreads(__tstate);
19472 if (PyErr_Occurred()) SWIG_fail;
19473 }
19474 {
19475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19476 }
19477 return resultobj;
19478 fail:
19479 return NULL;
19480 }
19481
19482
19483 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19484 PyObject *obj;
19485 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19486 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19487 Py_INCREF(obj);
19488 return Py_BuildValue((char *)"");
19489 }
19490 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19491 PyObject *resultobj;
19492 int arg1 = (int) 0 ;
19493 wxInitDialogEvent *result;
19494 PyObject * obj0 = 0 ;
19495 char *kwnames[] = {
19496 (char *) "Id", NULL
19497 };
19498
19499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19500 if (obj0) {
19501 {
19502 arg1 = (int)(SWIG_As_int(obj0));
19503 if (SWIG_arg_fail(1)) SWIG_fail;
19504 }
19505 }
19506 {
19507 PyThreadState* __tstate = wxPyBeginAllowThreads();
19508 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19509
19510 wxPyEndAllowThreads(__tstate);
19511 if (PyErr_Occurred()) SWIG_fail;
19512 }
19513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19514 return resultobj;
19515 fail:
19516 return NULL;
19517 }
19518
19519
19520 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19521 PyObject *obj;
19522 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19523 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19524 Py_INCREF(obj);
19525 return Py_BuildValue((char *)"");
19526 }
19527 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19528 PyObject *resultobj;
19529 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19530 int arg2 = (int) 0 ;
19531 wxMenu *arg3 = (wxMenu *) NULL ;
19532 wxMenuEvent *result;
19533 PyObject * obj0 = 0 ;
19534 PyObject * obj1 = 0 ;
19535 PyObject * obj2 = 0 ;
19536 char *kwnames[] = {
19537 (char *) "type",(char *) "winid",(char *) "menu", NULL
19538 };
19539
19540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19541 if (obj0) {
19542 {
19543 arg1 = (wxEventType)(SWIG_As_int(obj0));
19544 if (SWIG_arg_fail(1)) SWIG_fail;
19545 }
19546 }
19547 if (obj1) {
19548 {
19549 arg2 = (int)(SWIG_As_int(obj1));
19550 if (SWIG_arg_fail(2)) SWIG_fail;
19551 }
19552 }
19553 if (obj2) {
19554 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19555 if (SWIG_arg_fail(3)) SWIG_fail;
19556 }
19557 {
19558 PyThreadState* __tstate = wxPyBeginAllowThreads();
19559 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19560
19561 wxPyEndAllowThreads(__tstate);
19562 if (PyErr_Occurred()) SWIG_fail;
19563 }
19564 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19565 return resultobj;
19566 fail:
19567 return NULL;
19568 }
19569
19570
19571 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19572 PyObject *resultobj;
19573 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19574 int result;
19575 PyObject * obj0 = 0 ;
19576 char *kwnames[] = {
19577 (char *) "self", NULL
19578 };
19579
19580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19582 if (SWIG_arg_fail(1)) SWIG_fail;
19583 {
19584 PyThreadState* __tstate = wxPyBeginAllowThreads();
19585 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19586
19587 wxPyEndAllowThreads(__tstate);
19588 if (PyErr_Occurred()) SWIG_fail;
19589 }
19590 {
19591 resultobj = SWIG_From_int((int)(result));
19592 }
19593 return resultobj;
19594 fail:
19595 return NULL;
19596 }
19597
19598
19599 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19600 PyObject *resultobj;
19601 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19602 bool result;
19603 PyObject * obj0 = 0 ;
19604 char *kwnames[] = {
19605 (char *) "self", NULL
19606 };
19607
19608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19610 if (SWIG_arg_fail(1)) SWIG_fail;
19611 {
19612 PyThreadState* __tstate = wxPyBeginAllowThreads();
19613 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19614
19615 wxPyEndAllowThreads(__tstate);
19616 if (PyErr_Occurred()) SWIG_fail;
19617 }
19618 {
19619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19620 }
19621 return resultobj;
19622 fail:
19623 return NULL;
19624 }
19625
19626
19627 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
19628 PyObject *resultobj;
19629 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19630 wxMenu *result;
19631 PyObject * obj0 = 0 ;
19632 char *kwnames[] = {
19633 (char *) "self", NULL
19634 };
19635
19636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
19637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19638 if (SWIG_arg_fail(1)) SWIG_fail;
19639 {
19640 PyThreadState* __tstate = wxPyBeginAllowThreads();
19641 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
19642
19643 wxPyEndAllowThreads(__tstate);
19644 if (PyErr_Occurred()) SWIG_fail;
19645 }
19646 {
19647 resultobj = wxPyMake_wxObject(result, 0);
19648 }
19649 return resultobj;
19650 fail:
19651 return NULL;
19652 }
19653
19654
19655 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
19656 PyObject *obj;
19657 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19658 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
19659 Py_INCREF(obj);
19660 return Py_BuildValue((char *)"");
19661 }
19662 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19663 PyObject *resultobj;
19664 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19665 int arg2 = (int) 0 ;
19666 wxCloseEvent *result;
19667 PyObject * obj0 = 0 ;
19668 PyObject * obj1 = 0 ;
19669 char *kwnames[] = {
19670 (char *) "type",(char *) "winid", NULL
19671 };
19672
19673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
19674 if (obj0) {
19675 {
19676 arg1 = (wxEventType)(SWIG_As_int(obj0));
19677 if (SWIG_arg_fail(1)) SWIG_fail;
19678 }
19679 }
19680 if (obj1) {
19681 {
19682 arg2 = (int)(SWIG_As_int(obj1));
19683 if (SWIG_arg_fail(2)) SWIG_fail;
19684 }
19685 }
19686 {
19687 PyThreadState* __tstate = wxPyBeginAllowThreads();
19688 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
19689
19690 wxPyEndAllowThreads(__tstate);
19691 if (PyErr_Occurred()) SWIG_fail;
19692 }
19693 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
19694 return resultobj;
19695 fail:
19696 return NULL;
19697 }
19698
19699
19700 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19701 PyObject *resultobj;
19702 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19703 bool arg2 ;
19704 PyObject * obj0 = 0 ;
19705 PyObject * obj1 = 0 ;
19706 char *kwnames[] = {
19707 (char *) "self",(char *) "logOff", NULL
19708 };
19709
19710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
19711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19712 if (SWIG_arg_fail(1)) SWIG_fail;
19713 {
19714 arg2 = (bool)(SWIG_As_bool(obj1));
19715 if (SWIG_arg_fail(2)) SWIG_fail;
19716 }
19717 {
19718 PyThreadState* __tstate = wxPyBeginAllowThreads();
19719 (arg1)->SetLoggingOff(arg2);
19720
19721 wxPyEndAllowThreads(__tstate);
19722 if (PyErr_Occurred()) SWIG_fail;
19723 }
19724 Py_INCREF(Py_None); resultobj = Py_None;
19725 return resultobj;
19726 fail:
19727 return NULL;
19728 }
19729
19730
19731 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19732 PyObject *resultobj;
19733 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19734 bool result;
19735 PyObject * obj0 = 0 ;
19736 char *kwnames[] = {
19737 (char *) "self", NULL
19738 };
19739
19740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
19741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19742 if (SWIG_arg_fail(1)) SWIG_fail;
19743 {
19744 PyThreadState* __tstate = wxPyBeginAllowThreads();
19745 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
19746
19747 wxPyEndAllowThreads(__tstate);
19748 if (PyErr_Occurred()) SWIG_fail;
19749 }
19750 {
19751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19752 }
19753 return resultobj;
19754 fail:
19755 return NULL;
19756 }
19757
19758
19759 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
19760 PyObject *resultobj;
19761 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19762 bool arg2 = (bool) true ;
19763 PyObject * obj0 = 0 ;
19764 PyObject * obj1 = 0 ;
19765 char *kwnames[] = {
19766 (char *) "self",(char *) "veto", NULL
19767 };
19768
19769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
19770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19771 if (SWIG_arg_fail(1)) SWIG_fail;
19772 if (obj1) {
19773 {
19774 arg2 = (bool)(SWIG_As_bool(obj1));
19775 if (SWIG_arg_fail(2)) SWIG_fail;
19776 }
19777 }
19778 {
19779 PyThreadState* __tstate = wxPyBeginAllowThreads();
19780 (arg1)->Veto(arg2);
19781
19782 wxPyEndAllowThreads(__tstate);
19783 if (PyErr_Occurred()) SWIG_fail;
19784 }
19785 Py_INCREF(Py_None); resultobj = Py_None;
19786 return resultobj;
19787 fail:
19788 return NULL;
19789 }
19790
19791
19792 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19793 PyObject *resultobj;
19794 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19795 bool arg2 ;
19796 PyObject * obj0 = 0 ;
19797 PyObject * obj1 = 0 ;
19798 char *kwnames[] = {
19799 (char *) "self",(char *) "canVeto", NULL
19800 };
19801
19802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
19803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19804 if (SWIG_arg_fail(1)) SWIG_fail;
19805 {
19806 arg2 = (bool)(SWIG_As_bool(obj1));
19807 if (SWIG_arg_fail(2)) SWIG_fail;
19808 }
19809 {
19810 PyThreadState* __tstate = wxPyBeginAllowThreads();
19811 (arg1)->SetCanVeto(arg2);
19812
19813 wxPyEndAllowThreads(__tstate);
19814 if (PyErr_Occurred()) SWIG_fail;
19815 }
19816 Py_INCREF(Py_None); resultobj = Py_None;
19817 return resultobj;
19818 fail:
19819 return NULL;
19820 }
19821
19822
19823 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19824 PyObject *resultobj;
19825 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19826 bool result;
19827 PyObject * obj0 = 0 ;
19828 char *kwnames[] = {
19829 (char *) "self", NULL
19830 };
19831
19832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
19833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19834 if (SWIG_arg_fail(1)) SWIG_fail;
19835 {
19836 PyThreadState* __tstate = wxPyBeginAllowThreads();
19837 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
19838
19839 wxPyEndAllowThreads(__tstate);
19840 if (PyErr_Occurred()) SWIG_fail;
19841 }
19842 {
19843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19844 }
19845 return resultobj;
19846 fail:
19847 return NULL;
19848 }
19849
19850
19851 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19852 PyObject *resultobj;
19853 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19854 bool result;
19855 PyObject * obj0 = 0 ;
19856 char *kwnames[] = {
19857 (char *) "self", NULL
19858 };
19859
19860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
19861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19862 if (SWIG_arg_fail(1)) SWIG_fail;
19863 {
19864 PyThreadState* __tstate = wxPyBeginAllowThreads();
19865 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
19866
19867 wxPyEndAllowThreads(__tstate);
19868 if (PyErr_Occurred()) SWIG_fail;
19869 }
19870 {
19871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19872 }
19873 return resultobj;
19874 fail:
19875 return NULL;
19876 }
19877
19878
19879 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
19880 PyObject *obj;
19881 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19882 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
19883 Py_INCREF(obj);
19884 return Py_BuildValue((char *)"");
19885 }
19886 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19887 PyObject *resultobj;
19888 int arg1 = (int) 0 ;
19889 bool arg2 = (bool) false ;
19890 wxShowEvent *result;
19891 PyObject * obj0 = 0 ;
19892 PyObject * obj1 = 0 ;
19893 char *kwnames[] = {
19894 (char *) "winid",(char *) "show", NULL
19895 };
19896
19897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
19898 if (obj0) {
19899 {
19900 arg1 = (int)(SWIG_As_int(obj0));
19901 if (SWIG_arg_fail(1)) SWIG_fail;
19902 }
19903 }
19904 if (obj1) {
19905 {
19906 arg2 = (bool)(SWIG_As_bool(obj1));
19907 if (SWIG_arg_fail(2)) SWIG_fail;
19908 }
19909 }
19910 {
19911 PyThreadState* __tstate = wxPyBeginAllowThreads();
19912 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
19913
19914 wxPyEndAllowThreads(__tstate);
19915 if (PyErr_Occurred()) SWIG_fail;
19916 }
19917 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
19918 return resultobj;
19919 fail:
19920 return NULL;
19921 }
19922
19923
19924 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
19925 PyObject *resultobj;
19926 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
19927 bool arg2 ;
19928 PyObject * obj0 = 0 ;
19929 PyObject * obj1 = 0 ;
19930 char *kwnames[] = {
19931 (char *) "self",(char *) "show", NULL
19932 };
19933
19934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
19935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
19936 if (SWIG_arg_fail(1)) SWIG_fail;
19937 {
19938 arg2 = (bool)(SWIG_As_bool(obj1));
19939 if (SWIG_arg_fail(2)) SWIG_fail;
19940 }
19941 {
19942 PyThreadState* __tstate = wxPyBeginAllowThreads();
19943 (arg1)->SetShow(arg2);
19944
19945 wxPyEndAllowThreads(__tstate);
19946 if (PyErr_Occurred()) SWIG_fail;
19947 }
19948 Py_INCREF(Py_None); resultobj = Py_None;
19949 return resultobj;
19950 fail:
19951 return NULL;
19952 }
19953
19954
19955 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
19956 PyObject *resultobj;
19957 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
19958 bool result;
19959 PyObject * obj0 = 0 ;
19960 char *kwnames[] = {
19961 (char *) "self", NULL
19962 };
19963
19964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
19965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
19966 if (SWIG_arg_fail(1)) SWIG_fail;
19967 {
19968 PyThreadState* __tstate = wxPyBeginAllowThreads();
19969 result = (bool)((wxShowEvent const *)arg1)->GetShow();
19970
19971 wxPyEndAllowThreads(__tstate);
19972 if (PyErr_Occurred()) SWIG_fail;
19973 }
19974 {
19975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19976 }
19977 return resultobj;
19978 fail:
19979 return NULL;
19980 }
19981
19982
19983 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
19984 PyObject *obj;
19985 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19986 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
19987 Py_INCREF(obj);
19988 return Py_BuildValue((char *)"");
19989 }
19990 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19991 PyObject *resultobj;
19992 int arg1 = (int) 0 ;
19993 bool arg2 = (bool) true ;
19994 wxIconizeEvent *result;
19995 PyObject * obj0 = 0 ;
19996 PyObject * obj1 = 0 ;
19997 char *kwnames[] = {
19998 (char *) "id",(char *) "iconized", NULL
19999 };
20000
20001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20002 if (obj0) {
20003 {
20004 arg1 = (int)(SWIG_As_int(obj0));
20005 if (SWIG_arg_fail(1)) SWIG_fail;
20006 }
20007 }
20008 if (obj1) {
20009 {
20010 arg2 = (bool)(SWIG_As_bool(obj1));
20011 if (SWIG_arg_fail(2)) SWIG_fail;
20012 }
20013 }
20014 {
20015 PyThreadState* __tstate = wxPyBeginAllowThreads();
20016 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20017
20018 wxPyEndAllowThreads(__tstate);
20019 if (PyErr_Occurred()) SWIG_fail;
20020 }
20021 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20022 return resultobj;
20023 fail:
20024 return NULL;
20025 }
20026
20027
20028 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20029 PyObject *resultobj;
20030 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20031 bool result;
20032 PyObject * obj0 = 0 ;
20033 char *kwnames[] = {
20034 (char *) "self", NULL
20035 };
20036
20037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20039 if (SWIG_arg_fail(1)) SWIG_fail;
20040 {
20041 PyThreadState* __tstate = wxPyBeginAllowThreads();
20042 result = (bool)(arg1)->Iconized();
20043
20044 wxPyEndAllowThreads(__tstate);
20045 if (PyErr_Occurred()) SWIG_fail;
20046 }
20047 {
20048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20049 }
20050 return resultobj;
20051 fail:
20052 return NULL;
20053 }
20054
20055
20056 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20057 PyObject *obj;
20058 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20059 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20060 Py_INCREF(obj);
20061 return Py_BuildValue((char *)"");
20062 }
20063 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20064 PyObject *resultobj;
20065 int arg1 = (int) 0 ;
20066 wxMaximizeEvent *result;
20067 PyObject * obj0 = 0 ;
20068 char *kwnames[] = {
20069 (char *) "id", NULL
20070 };
20071
20072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20073 if (obj0) {
20074 {
20075 arg1 = (int)(SWIG_As_int(obj0));
20076 if (SWIG_arg_fail(1)) SWIG_fail;
20077 }
20078 }
20079 {
20080 PyThreadState* __tstate = wxPyBeginAllowThreads();
20081 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20082
20083 wxPyEndAllowThreads(__tstate);
20084 if (PyErr_Occurred()) SWIG_fail;
20085 }
20086 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20087 return resultobj;
20088 fail:
20089 return NULL;
20090 }
20091
20092
20093 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20094 PyObject *obj;
20095 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20096 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20097 Py_INCREF(obj);
20098 return Py_BuildValue((char *)"");
20099 }
20100 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20101 PyObject *resultobj;
20102 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20103 wxPoint result;
20104 PyObject * obj0 = 0 ;
20105 char *kwnames[] = {
20106 (char *) "self", NULL
20107 };
20108
20109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20111 if (SWIG_arg_fail(1)) SWIG_fail;
20112 {
20113 PyThreadState* __tstate = wxPyBeginAllowThreads();
20114 result = (arg1)->GetPosition();
20115
20116 wxPyEndAllowThreads(__tstate);
20117 if (PyErr_Occurred()) SWIG_fail;
20118 }
20119 {
20120 wxPoint * resultptr;
20121 resultptr = new wxPoint((wxPoint &)(result));
20122 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20123 }
20124 return resultobj;
20125 fail:
20126 return NULL;
20127 }
20128
20129
20130 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20131 PyObject *resultobj;
20132 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20133 int result;
20134 PyObject * obj0 = 0 ;
20135 char *kwnames[] = {
20136 (char *) "self", NULL
20137 };
20138
20139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20141 if (SWIG_arg_fail(1)) SWIG_fail;
20142 {
20143 PyThreadState* __tstate = wxPyBeginAllowThreads();
20144 result = (int)(arg1)->GetNumberOfFiles();
20145
20146 wxPyEndAllowThreads(__tstate);
20147 if (PyErr_Occurred()) SWIG_fail;
20148 }
20149 {
20150 resultobj = SWIG_From_int((int)(result));
20151 }
20152 return resultobj;
20153 fail:
20154 return NULL;
20155 }
20156
20157
20158 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20159 PyObject *resultobj;
20160 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20161 PyObject *result;
20162 PyObject * obj0 = 0 ;
20163 char *kwnames[] = {
20164 (char *) "self", NULL
20165 };
20166
20167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20169 if (SWIG_arg_fail(1)) SWIG_fail;
20170 {
20171 PyThreadState* __tstate = wxPyBeginAllowThreads();
20172 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20173
20174 wxPyEndAllowThreads(__tstate);
20175 if (PyErr_Occurred()) SWIG_fail;
20176 }
20177 resultobj = result;
20178 return resultobj;
20179 fail:
20180 return NULL;
20181 }
20182
20183
20184 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20185 PyObject *obj;
20186 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20187 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20188 Py_INCREF(obj);
20189 return Py_BuildValue((char *)"");
20190 }
20191 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20192 PyObject *resultobj;
20193 int arg1 = (int) 0 ;
20194 wxUpdateUIEvent *result;
20195 PyObject * obj0 = 0 ;
20196 char *kwnames[] = {
20197 (char *) "commandId", NULL
20198 };
20199
20200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20201 if (obj0) {
20202 {
20203 arg1 = (int)(SWIG_As_int(obj0));
20204 if (SWIG_arg_fail(1)) SWIG_fail;
20205 }
20206 }
20207 {
20208 PyThreadState* __tstate = wxPyBeginAllowThreads();
20209 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20210
20211 wxPyEndAllowThreads(__tstate);
20212 if (PyErr_Occurred()) SWIG_fail;
20213 }
20214 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20215 return resultobj;
20216 fail:
20217 return NULL;
20218 }
20219
20220
20221 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20222 PyObject *resultobj;
20223 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20224 bool result;
20225 PyObject * obj0 = 0 ;
20226 char *kwnames[] = {
20227 (char *) "self", NULL
20228 };
20229
20230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20232 if (SWIG_arg_fail(1)) SWIG_fail;
20233 {
20234 PyThreadState* __tstate = wxPyBeginAllowThreads();
20235 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20236
20237 wxPyEndAllowThreads(__tstate);
20238 if (PyErr_Occurred()) SWIG_fail;
20239 }
20240 {
20241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20242 }
20243 return resultobj;
20244 fail:
20245 return NULL;
20246 }
20247
20248
20249 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20250 PyObject *resultobj;
20251 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20252 bool result;
20253 PyObject * obj0 = 0 ;
20254 char *kwnames[] = {
20255 (char *) "self", NULL
20256 };
20257
20258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20260 if (SWIG_arg_fail(1)) SWIG_fail;
20261 {
20262 PyThreadState* __tstate = wxPyBeginAllowThreads();
20263 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20264
20265 wxPyEndAllowThreads(__tstate);
20266 if (PyErr_Occurred()) SWIG_fail;
20267 }
20268 {
20269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20270 }
20271 return resultobj;
20272 fail:
20273 return NULL;
20274 }
20275
20276
20277 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20278 PyObject *resultobj;
20279 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20280 wxString result;
20281 PyObject * obj0 = 0 ;
20282 char *kwnames[] = {
20283 (char *) "self", NULL
20284 };
20285
20286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20288 if (SWIG_arg_fail(1)) SWIG_fail;
20289 {
20290 PyThreadState* __tstate = wxPyBeginAllowThreads();
20291 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20292
20293 wxPyEndAllowThreads(__tstate);
20294 if (PyErr_Occurred()) SWIG_fail;
20295 }
20296 {
20297 #if wxUSE_UNICODE
20298 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20299 #else
20300 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20301 #endif
20302 }
20303 return resultobj;
20304 fail:
20305 return NULL;
20306 }
20307
20308
20309 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20310 PyObject *resultobj;
20311 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20312 bool result;
20313 PyObject * obj0 = 0 ;
20314 char *kwnames[] = {
20315 (char *) "self", NULL
20316 };
20317
20318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20320 if (SWIG_arg_fail(1)) SWIG_fail;
20321 {
20322 PyThreadState* __tstate = wxPyBeginAllowThreads();
20323 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20324
20325 wxPyEndAllowThreads(__tstate);
20326 if (PyErr_Occurred()) SWIG_fail;
20327 }
20328 {
20329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20330 }
20331 return resultobj;
20332 fail:
20333 return NULL;
20334 }
20335
20336
20337 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20338 PyObject *resultobj;
20339 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20340 bool result;
20341 PyObject * obj0 = 0 ;
20342 char *kwnames[] = {
20343 (char *) "self", NULL
20344 };
20345
20346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20348 if (SWIG_arg_fail(1)) SWIG_fail;
20349 {
20350 PyThreadState* __tstate = wxPyBeginAllowThreads();
20351 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20352
20353 wxPyEndAllowThreads(__tstate);
20354 if (PyErr_Occurred()) SWIG_fail;
20355 }
20356 {
20357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20358 }
20359 return resultobj;
20360 fail:
20361 return NULL;
20362 }
20363
20364
20365 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20366 PyObject *resultobj;
20367 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20368 bool result;
20369 PyObject * obj0 = 0 ;
20370 char *kwnames[] = {
20371 (char *) "self", NULL
20372 };
20373
20374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20376 if (SWIG_arg_fail(1)) SWIG_fail;
20377 {
20378 PyThreadState* __tstate = wxPyBeginAllowThreads();
20379 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20380
20381 wxPyEndAllowThreads(__tstate);
20382 if (PyErr_Occurred()) SWIG_fail;
20383 }
20384 {
20385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20386 }
20387 return resultobj;
20388 fail:
20389 return NULL;
20390 }
20391
20392
20393 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20394 PyObject *resultobj;
20395 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20396 bool arg2 ;
20397 PyObject * obj0 = 0 ;
20398 PyObject * obj1 = 0 ;
20399 char *kwnames[] = {
20400 (char *) "self",(char *) "check", NULL
20401 };
20402
20403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20405 if (SWIG_arg_fail(1)) SWIG_fail;
20406 {
20407 arg2 = (bool)(SWIG_As_bool(obj1));
20408 if (SWIG_arg_fail(2)) SWIG_fail;
20409 }
20410 {
20411 PyThreadState* __tstate = wxPyBeginAllowThreads();
20412 (arg1)->Check(arg2);
20413
20414 wxPyEndAllowThreads(__tstate);
20415 if (PyErr_Occurred()) SWIG_fail;
20416 }
20417 Py_INCREF(Py_None); resultobj = Py_None;
20418 return resultobj;
20419 fail:
20420 return NULL;
20421 }
20422
20423
20424 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20425 PyObject *resultobj;
20426 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20427 bool arg2 ;
20428 PyObject * obj0 = 0 ;
20429 PyObject * obj1 = 0 ;
20430 char *kwnames[] = {
20431 (char *) "self",(char *) "enable", NULL
20432 };
20433
20434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20436 if (SWIG_arg_fail(1)) SWIG_fail;
20437 {
20438 arg2 = (bool)(SWIG_As_bool(obj1));
20439 if (SWIG_arg_fail(2)) SWIG_fail;
20440 }
20441 {
20442 PyThreadState* __tstate = wxPyBeginAllowThreads();
20443 (arg1)->Enable(arg2);
20444
20445 wxPyEndAllowThreads(__tstate);
20446 if (PyErr_Occurred()) SWIG_fail;
20447 }
20448 Py_INCREF(Py_None); resultobj = Py_None;
20449 return resultobj;
20450 fail:
20451 return NULL;
20452 }
20453
20454
20455 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20456 PyObject *resultobj;
20457 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20458 wxString *arg2 = 0 ;
20459 bool temp2 = false ;
20460 PyObject * obj0 = 0 ;
20461 PyObject * obj1 = 0 ;
20462 char *kwnames[] = {
20463 (char *) "self",(char *) "text", NULL
20464 };
20465
20466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20468 if (SWIG_arg_fail(1)) SWIG_fail;
20469 {
20470 arg2 = wxString_in_helper(obj1);
20471 if (arg2 == NULL) SWIG_fail;
20472 temp2 = true;
20473 }
20474 {
20475 PyThreadState* __tstate = wxPyBeginAllowThreads();
20476 (arg1)->SetText((wxString const &)*arg2);
20477
20478 wxPyEndAllowThreads(__tstate);
20479 if (PyErr_Occurred()) SWIG_fail;
20480 }
20481 Py_INCREF(Py_None); resultobj = Py_None;
20482 {
20483 if (temp2)
20484 delete arg2;
20485 }
20486 return resultobj;
20487 fail:
20488 {
20489 if (temp2)
20490 delete arg2;
20491 }
20492 return NULL;
20493 }
20494
20495
20496 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20497 PyObject *resultobj;
20498 long arg1 ;
20499 PyObject * obj0 = 0 ;
20500 char *kwnames[] = {
20501 (char *) "updateInterval", NULL
20502 };
20503
20504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20505 {
20506 arg1 = (long)(SWIG_As_long(obj0));
20507 if (SWIG_arg_fail(1)) SWIG_fail;
20508 }
20509 {
20510 PyThreadState* __tstate = wxPyBeginAllowThreads();
20511 wxUpdateUIEvent::SetUpdateInterval(arg1);
20512
20513 wxPyEndAllowThreads(__tstate);
20514 if (PyErr_Occurred()) SWIG_fail;
20515 }
20516 Py_INCREF(Py_None); resultobj = Py_None;
20517 return resultobj;
20518 fail:
20519 return NULL;
20520 }
20521
20522
20523 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20524 PyObject *resultobj;
20525 long result;
20526 char *kwnames[] = {
20527 NULL
20528 };
20529
20530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20531 {
20532 PyThreadState* __tstate = wxPyBeginAllowThreads();
20533 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20534
20535 wxPyEndAllowThreads(__tstate);
20536 if (PyErr_Occurred()) SWIG_fail;
20537 }
20538 {
20539 resultobj = SWIG_From_long((long)(result));
20540 }
20541 return resultobj;
20542 fail:
20543 return NULL;
20544 }
20545
20546
20547 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20548 PyObject *resultobj;
20549 wxWindow *arg1 = (wxWindow *) 0 ;
20550 bool result;
20551 PyObject * obj0 = 0 ;
20552 char *kwnames[] = {
20553 (char *) "win", NULL
20554 };
20555
20556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20558 if (SWIG_arg_fail(1)) SWIG_fail;
20559 {
20560 PyThreadState* __tstate = wxPyBeginAllowThreads();
20561 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20562
20563 wxPyEndAllowThreads(__tstate);
20564 if (PyErr_Occurred()) SWIG_fail;
20565 }
20566 {
20567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20568 }
20569 return resultobj;
20570 fail:
20571 return NULL;
20572 }
20573
20574
20575 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20576 PyObject *resultobj;
20577 char *kwnames[] = {
20578 NULL
20579 };
20580
20581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20582 {
20583 PyThreadState* __tstate = wxPyBeginAllowThreads();
20584 wxUpdateUIEvent::ResetUpdateTime();
20585
20586 wxPyEndAllowThreads(__tstate);
20587 if (PyErr_Occurred()) SWIG_fail;
20588 }
20589 Py_INCREF(Py_None); resultobj = Py_None;
20590 return resultobj;
20591 fail:
20592 return NULL;
20593 }
20594
20595
20596 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20597 PyObject *resultobj;
20598 wxUpdateUIMode arg1 ;
20599 PyObject * obj0 = 0 ;
20600 char *kwnames[] = {
20601 (char *) "mode", NULL
20602 };
20603
20604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20605 {
20606 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20607 if (SWIG_arg_fail(1)) SWIG_fail;
20608 }
20609 {
20610 PyThreadState* __tstate = wxPyBeginAllowThreads();
20611 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20612
20613 wxPyEndAllowThreads(__tstate);
20614 if (PyErr_Occurred()) SWIG_fail;
20615 }
20616 Py_INCREF(Py_None); resultobj = Py_None;
20617 return resultobj;
20618 fail:
20619 return NULL;
20620 }
20621
20622
20623 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20624 PyObject *resultobj;
20625 wxUpdateUIMode result;
20626 char *kwnames[] = {
20627 NULL
20628 };
20629
20630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
20631 {
20632 PyThreadState* __tstate = wxPyBeginAllowThreads();
20633 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
20634
20635 wxPyEndAllowThreads(__tstate);
20636 if (PyErr_Occurred()) SWIG_fail;
20637 }
20638 resultobj = SWIG_From_int((result));
20639 return resultobj;
20640 fail:
20641 return NULL;
20642 }
20643
20644
20645 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
20646 PyObject *obj;
20647 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20648 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
20649 Py_INCREF(obj);
20650 return Py_BuildValue((char *)"");
20651 }
20652 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20653 PyObject *resultobj;
20654 wxSysColourChangedEvent *result;
20655 char *kwnames[] = {
20656 NULL
20657 };
20658
20659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
20660 {
20661 PyThreadState* __tstate = wxPyBeginAllowThreads();
20662 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
20663
20664 wxPyEndAllowThreads(__tstate);
20665 if (PyErr_Occurred()) SWIG_fail;
20666 }
20667 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
20668 return resultobj;
20669 fail:
20670 return NULL;
20671 }
20672
20673
20674 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
20675 PyObject *obj;
20676 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20677 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
20678 Py_INCREF(obj);
20679 return Py_BuildValue((char *)"");
20680 }
20681 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20682 PyObject *resultobj;
20683 int arg1 = (int) 0 ;
20684 wxWindow *arg2 = (wxWindow *) NULL ;
20685 wxMouseCaptureChangedEvent *result;
20686 PyObject * obj0 = 0 ;
20687 PyObject * obj1 = 0 ;
20688 char *kwnames[] = {
20689 (char *) "winid",(char *) "gainedCapture", NULL
20690 };
20691
20692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
20693 if (obj0) {
20694 {
20695 arg1 = (int)(SWIG_As_int(obj0));
20696 if (SWIG_arg_fail(1)) SWIG_fail;
20697 }
20698 }
20699 if (obj1) {
20700 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20701 if (SWIG_arg_fail(2)) SWIG_fail;
20702 }
20703 {
20704 PyThreadState* __tstate = wxPyBeginAllowThreads();
20705 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
20706
20707 wxPyEndAllowThreads(__tstate);
20708 if (PyErr_Occurred()) SWIG_fail;
20709 }
20710 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
20711 return resultobj;
20712 fail:
20713 return NULL;
20714 }
20715
20716
20717 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20718 PyObject *resultobj;
20719 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
20720 wxWindow *result;
20721 PyObject * obj0 = 0 ;
20722 char *kwnames[] = {
20723 (char *) "self", NULL
20724 };
20725
20726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
20727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20728 if (SWIG_arg_fail(1)) SWIG_fail;
20729 {
20730 PyThreadState* __tstate = wxPyBeginAllowThreads();
20731 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
20732
20733 wxPyEndAllowThreads(__tstate);
20734 if (PyErr_Occurred()) SWIG_fail;
20735 }
20736 {
20737 resultobj = wxPyMake_wxObject(result, 0);
20738 }
20739 return resultobj;
20740 fail:
20741 return NULL;
20742 }
20743
20744
20745 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
20746 PyObject *obj;
20747 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20748 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
20749 Py_INCREF(obj);
20750 return Py_BuildValue((char *)"");
20751 }
20752 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20753 PyObject *resultobj;
20754 wxDisplayChangedEvent *result;
20755 char *kwnames[] = {
20756 NULL
20757 };
20758
20759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
20760 {
20761 PyThreadState* __tstate = wxPyBeginAllowThreads();
20762 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
20763
20764 wxPyEndAllowThreads(__tstate);
20765 if (PyErr_Occurred()) SWIG_fail;
20766 }
20767 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
20768 return resultobj;
20769 fail:
20770 return NULL;
20771 }
20772
20773
20774 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
20775 PyObject *obj;
20776 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20777 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
20778 Py_INCREF(obj);
20779 return Py_BuildValue((char *)"");
20780 }
20781 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20782 PyObject *resultobj;
20783 int arg1 = (int) 0 ;
20784 wxPaletteChangedEvent *result;
20785 PyObject * obj0 = 0 ;
20786 char *kwnames[] = {
20787 (char *) "id", NULL
20788 };
20789
20790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
20791 if (obj0) {
20792 {
20793 arg1 = (int)(SWIG_As_int(obj0));
20794 if (SWIG_arg_fail(1)) SWIG_fail;
20795 }
20796 }
20797 {
20798 PyThreadState* __tstate = wxPyBeginAllowThreads();
20799 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
20800
20801 wxPyEndAllowThreads(__tstate);
20802 if (PyErr_Occurred()) SWIG_fail;
20803 }
20804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
20805 return resultobj;
20806 fail:
20807 return NULL;
20808 }
20809
20810
20811 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20812 PyObject *resultobj;
20813 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20814 wxWindow *arg2 = (wxWindow *) 0 ;
20815 PyObject * obj0 = 0 ;
20816 PyObject * obj1 = 0 ;
20817 char *kwnames[] = {
20818 (char *) "self",(char *) "win", NULL
20819 };
20820
20821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
20822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20823 if (SWIG_arg_fail(1)) SWIG_fail;
20824 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20825 if (SWIG_arg_fail(2)) SWIG_fail;
20826 {
20827 PyThreadState* __tstate = wxPyBeginAllowThreads();
20828 (arg1)->SetChangedWindow(arg2);
20829
20830 wxPyEndAllowThreads(__tstate);
20831 if (PyErr_Occurred()) SWIG_fail;
20832 }
20833 Py_INCREF(Py_None); resultobj = Py_None;
20834 return resultobj;
20835 fail:
20836 return NULL;
20837 }
20838
20839
20840 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20841 PyObject *resultobj;
20842 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20843 wxWindow *result;
20844 PyObject * obj0 = 0 ;
20845 char *kwnames[] = {
20846 (char *) "self", NULL
20847 };
20848
20849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
20850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20851 if (SWIG_arg_fail(1)) SWIG_fail;
20852 {
20853 PyThreadState* __tstate = wxPyBeginAllowThreads();
20854 result = (wxWindow *)(arg1)->GetChangedWindow();
20855
20856 wxPyEndAllowThreads(__tstate);
20857 if (PyErr_Occurred()) SWIG_fail;
20858 }
20859 {
20860 resultobj = wxPyMake_wxObject(result, 0);
20861 }
20862 return resultobj;
20863 fail:
20864 return NULL;
20865 }
20866
20867
20868 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
20869 PyObject *obj;
20870 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20871 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
20872 Py_INCREF(obj);
20873 return Py_BuildValue((char *)"");
20874 }
20875 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20876 PyObject *resultobj;
20877 int arg1 = (int) 0 ;
20878 wxQueryNewPaletteEvent *result;
20879 PyObject * obj0 = 0 ;
20880 char *kwnames[] = {
20881 (char *) "winid", NULL
20882 };
20883
20884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
20885 if (obj0) {
20886 {
20887 arg1 = (int)(SWIG_As_int(obj0));
20888 if (SWIG_arg_fail(1)) SWIG_fail;
20889 }
20890 }
20891 {
20892 PyThreadState* __tstate = wxPyBeginAllowThreads();
20893 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
20894
20895 wxPyEndAllowThreads(__tstate);
20896 if (PyErr_Occurred()) SWIG_fail;
20897 }
20898 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
20899 return resultobj;
20900 fail:
20901 return NULL;
20902 }
20903
20904
20905 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20906 PyObject *resultobj;
20907 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20908 bool arg2 ;
20909 PyObject * obj0 = 0 ;
20910 PyObject * obj1 = 0 ;
20911 char *kwnames[] = {
20912 (char *) "self",(char *) "realized", NULL
20913 };
20914
20915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
20916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
20917 if (SWIG_arg_fail(1)) SWIG_fail;
20918 {
20919 arg2 = (bool)(SWIG_As_bool(obj1));
20920 if (SWIG_arg_fail(2)) SWIG_fail;
20921 }
20922 {
20923 PyThreadState* __tstate = wxPyBeginAllowThreads();
20924 (arg1)->SetPaletteRealized(arg2);
20925
20926 wxPyEndAllowThreads(__tstate);
20927 if (PyErr_Occurred()) SWIG_fail;
20928 }
20929 Py_INCREF(Py_None); resultobj = Py_None;
20930 return resultobj;
20931 fail:
20932 return NULL;
20933 }
20934
20935
20936 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20937 PyObject *resultobj;
20938 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20939 bool result;
20940 PyObject * obj0 = 0 ;
20941 char *kwnames[] = {
20942 (char *) "self", NULL
20943 };
20944
20945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
20946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
20947 if (SWIG_arg_fail(1)) SWIG_fail;
20948 {
20949 PyThreadState* __tstate = wxPyBeginAllowThreads();
20950 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
20951
20952 wxPyEndAllowThreads(__tstate);
20953 if (PyErr_Occurred()) SWIG_fail;
20954 }
20955 {
20956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20957 }
20958 return resultobj;
20959 fail:
20960 return NULL;
20961 }
20962
20963
20964 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
20965 PyObject *obj;
20966 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20967 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
20968 Py_INCREF(obj);
20969 return Py_BuildValue((char *)"");
20970 }
20971 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20972 PyObject *resultobj;
20973 wxNavigationKeyEvent *result;
20974 char *kwnames[] = {
20975 NULL
20976 };
20977
20978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
20979 {
20980 PyThreadState* __tstate = wxPyBeginAllowThreads();
20981 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
20982
20983 wxPyEndAllowThreads(__tstate);
20984 if (PyErr_Occurred()) SWIG_fail;
20985 }
20986 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
20987 return resultobj;
20988 fail:
20989 return NULL;
20990 }
20991
20992
20993 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
20994 PyObject *resultobj;
20995 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
20996 bool result;
20997 PyObject * obj0 = 0 ;
20998 char *kwnames[] = {
20999 (char *) "self", NULL
21000 };
21001
21002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21004 if (SWIG_arg_fail(1)) SWIG_fail;
21005 {
21006 PyThreadState* __tstate = wxPyBeginAllowThreads();
21007 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21008
21009 wxPyEndAllowThreads(__tstate);
21010 if (PyErr_Occurred()) SWIG_fail;
21011 }
21012 {
21013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21014 }
21015 return resultobj;
21016 fail:
21017 return NULL;
21018 }
21019
21020
21021 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21022 PyObject *resultobj;
21023 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21024 bool arg2 ;
21025 PyObject * obj0 = 0 ;
21026 PyObject * obj1 = 0 ;
21027 char *kwnames[] = {
21028 (char *) "self",(char *) "forward", NULL
21029 };
21030
21031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21033 if (SWIG_arg_fail(1)) SWIG_fail;
21034 {
21035 arg2 = (bool)(SWIG_As_bool(obj1));
21036 if (SWIG_arg_fail(2)) SWIG_fail;
21037 }
21038 {
21039 PyThreadState* __tstate = wxPyBeginAllowThreads();
21040 (arg1)->SetDirection(arg2);
21041
21042 wxPyEndAllowThreads(__tstate);
21043 if (PyErr_Occurred()) SWIG_fail;
21044 }
21045 Py_INCREF(Py_None); resultobj = Py_None;
21046 return resultobj;
21047 fail:
21048 return NULL;
21049 }
21050
21051
21052 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21053 PyObject *resultobj;
21054 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21055 bool result;
21056 PyObject * obj0 = 0 ;
21057 char *kwnames[] = {
21058 (char *) "self", NULL
21059 };
21060
21061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21063 if (SWIG_arg_fail(1)) SWIG_fail;
21064 {
21065 PyThreadState* __tstate = wxPyBeginAllowThreads();
21066 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21067
21068 wxPyEndAllowThreads(__tstate);
21069 if (PyErr_Occurred()) SWIG_fail;
21070 }
21071 {
21072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21073 }
21074 return resultobj;
21075 fail:
21076 return NULL;
21077 }
21078
21079
21080 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21081 PyObject *resultobj;
21082 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21083 bool arg2 ;
21084 PyObject * obj0 = 0 ;
21085 PyObject * obj1 = 0 ;
21086 char *kwnames[] = {
21087 (char *) "self",(char *) "ischange", NULL
21088 };
21089
21090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21092 if (SWIG_arg_fail(1)) SWIG_fail;
21093 {
21094 arg2 = (bool)(SWIG_As_bool(obj1));
21095 if (SWIG_arg_fail(2)) SWIG_fail;
21096 }
21097 {
21098 PyThreadState* __tstate = wxPyBeginAllowThreads();
21099 (arg1)->SetWindowChange(arg2);
21100
21101 wxPyEndAllowThreads(__tstate);
21102 if (PyErr_Occurred()) SWIG_fail;
21103 }
21104 Py_INCREF(Py_None); resultobj = Py_None;
21105 return resultobj;
21106 fail:
21107 return NULL;
21108 }
21109
21110
21111 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21112 PyObject *resultobj;
21113 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21114 long arg2 ;
21115 PyObject * obj0 = 0 ;
21116 PyObject * obj1 = 0 ;
21117 char *kwnames[] = {
21118 (char *) "self",(char *) "flags", NULL
21119 };
21120
21121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21123 if (SWIG_arg_fail(1)) SWIG_fail;
21124 {
21125 arg2 = (long)(SWIG_As_long(obj1));
21126 if (SWIG_arg_fail(2)) SWIG_fail;
21127 }
21128 {
21129 PyThreadState* __tstate = wxPyBeginAllowThreads();
21130 (arg1)->SetFlags(arg2);
21131
21132 wxPyEndAllowThreads(__tstate);
21133 if (PyErr_Occurred()) SWIG_fail;
21134 }
21135 Py_INCREF(Py_None); resultobj = Py_None;
21136 return resultobj;
21137 fail:
21138 return NULL;
21139 }
21140
21141
21142 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21143 PyObject *resultobj;
21144 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21145 wxWindow *result;
21146 PyObject * obj0 = 0 ;
21147 char *kwnames[] = {
21148 (char *) "self", NULL
21149 };
21150
21151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21153 if (SWIG_arg_fail(1)) SWIG_fail;
21154 {
21155 PyThreadState* __tstate = wxPyBeginAllowThreads();
21156 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21157
21158 wxPyEndAllowThreads(__tstate);
21159 if (PyErr_Occurred()) SWIG_fail;
21160 }
21161 {
21162 resultobj = wxPyMake_wxObject(result, 0);
21163 }
21164 return resultobj;
21165 fail:
21166 return NULL;
21167 }
21168
21169
21170 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21171 PyObject *resultobj;
21172 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21173 wxWindow *arg2 = (wxWindow *) 0 ;
21174 PyObject * obj0 = 0 ;
21175 PyObject * obj1 = 0 ;
21176 char *kwnames[] = {
21177 (char *) "self",(char *) "win", NULL
21178 };
21179
21180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21182 if (SWIG_arg_fail(1)) SWIG_fail;
21183 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21184 if (SWIG_arg_fail(2)) SWIG_fail;
21185 {
21186 PyThreadState* __tstate = wxPyBeginAllowThreads();
21187 (arg1)->SetCurrentFocus(arg2);
21188
21189 wxPyEndAllowThreads(__tstate);
21190 if (PyErr_Occurred()) SWIG_fail;
21191 }
21192 Py_INCREF(Py_None); resultobj = Py_None;
21193 return resultobj;
21194 fail:
21195 return NULL;
21196 }
21197
21198
21199 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21200 PyObject *obj;
21201 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21202 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21203 Py_INCREF(obj);
21204 return Py_BuildValue((char *)"");
21205 }
21206 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21207 PyObject *resultobj;
21208 wxWindow *arg1 = (wxWindow *) NULL ;
21209 wxWindowCreateEvent *result;
21210 PyObject * obj0 = 0 ;
21211 char *kwnames[] = {
21212 (char *) "win", NULL
21213 };
21214
21215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21216 if (obj0) {
21217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21218 if (SWIG_arg_fail(1)) SWIG_fail;
21219 }
21220 {
21221 PyThreadState* __tstate = wxPyBeginAllowThreads();
21222 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21223
21224 wxPyEndAllowThreads(__tstate);
21225 if (PyErr_Occurred()) SWIG_fail;
21226 }
21227 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21228 return resultobj;
21229 fail:
21230 return NULL;
21231 }
21232
21233
21234 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21235 PyObject *resultobj;
21236 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21237 wxWindow *result;
21238 PyObject * obj0 = 0 ;
21239 char *kwnames[] = {
21240 (char *) "self", NULL
21241 };
21242
21243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21245 if (SWIG_arg_fail(1)) SWIG_fail;
21246 {
21247 PyThreadState* __tstate = wxPyBeginAllowThreads();
21248 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21249
21250 wxPyEndAllowThreads(__tstate);
21251 if (PyErr_Occurred()) SWIG_fail;
21252 }
21253 {
21254 resultobj = wxPyMake_wxObject(result, 0);
21255 }
21256 return resultobj;
21257 fail:
21258 return NULL;
21259 }
21260
21261
21262 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21263 PyObject *obj;
21264 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21265 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21266 Py_INCREF(obj);
21267 return Py_BuildValue((char *)"");
21268 }
21269 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21270 PyObject *resultobj;
21271 wxWindow *arg1 = (wxWindow *) NULL ;
21272 wxWindowDestroyEvent *result;
21273 PyObject * obj0 = 0 ;
21274 char *kwnames[] = {
21275 (char *) "win", NULL
21276 };
21277
21278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21279 if (obj0) {
21280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21281 if (SWIG_arg_fail(1)) SWIG_fail;
21282 }
21283 {
21284 PyThreadState* __tstate = wxPyBeginAllowThreads();
21285 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21286
21287 wxPyEndAllowThreads(__tstate);
21288 if (PyErr_Occurred()) SWIG_fail;
21289 }
21290 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21291 return resultobj;
21292 fail:
21293 return NULL;
21294 }
21295
21296
21297 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21298 PyObject *resultobj;
21299 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21300 wxWindow *result;
21301 PyObject * obj0 = 0 ;
21302 char *kwnames[] = {
21303 (char *) "self", NULL
21304 };
21305
21306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21308 if (SWIG_arg_fail(1)) SWIG_fail;
21309 {
21310 PyThreadState* __tstate = wxPyBeginAllowThreads();
21311 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21312
21313 wxPyEndAllowThreads(__tstate);
21314 if (PyErr_Occurred()) SWIG_fail;
21315 }
21316 {
21317 resultobj = wxPyMake_wxObject(result, 0);
21318 }
21319 return resultobj;
21320 fail:
21321 return NULL;
21322 }
21323
21324
21325 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21326 PyObject *obj;
21327 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21328 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21329 Py_INCREF(obj);
21330 return Py_BuildValue((char *)"");
21331 }
21332 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21333 PyObject *resultobj;
21334 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21335 int arg2 = (int) 0 ;
21336 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21337 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21338 wxContextMenuEvent *result;
21339 wxPoint temp3 ;
21340 PyObject * obj0 = 0 ;
21341 PyObject * obj1 = 0 ;
21342 PyObject * obj2 = 0 ;
21343 char *kwnames[] = {
21344 (char *) "type",(char *) "winid",(char *) "pt", NULL
21345 };
21346
21347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21348 if (obj0) {
21349 {
21350 arg1 = (wxEventType)(SWIG_As_int(obj0));
21351 if (SWIG_arg_fail(1)) SWIG_fail;
21352 }
21353 }
21354 if (obj1) {
21355 {
21356 arg2 = (int)(SWIG_As_int(obj1));
21357 if (SWIG_arg_fail(2)) SWIG_fail;
21358 }
21359 }
21360 if (obj2) {
21361 {
21362 arg3 = &temp3;
21363 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21364 }
21365 }
21366 {
21367 PyThreadState* __tstate = wxPyBeginAllowThreads();
21368 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21369
21370 wxPyEndAllowThreads(__tstate);
21371 if (PyErr_Occurred()) SWIG_fail;
21372 }
21373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21374 return resultobj;
21375 fail:
21376 return NULL;
21377 }
21378
21379
21380 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21381 PyObject *resultobj;
21382 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21383 wxPoint *result;
21384 PyObject * obj0 = 0 ;
21385 char *kwnames[] = {
21386 (char *) "self", NULL
21387 };
21388
21389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21391 if (SWIG_arg_fail(1)) SWIG_fail;
21392 {
21393 PyThreadState* __tstate = wxPyBeginAllowThreads();
21394 {
21395 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21396 result = (wxPoint *) &_result_ref;
21397 }
21398
21399 wxPyEndAllowThreads(__tstate);
21400 if (PyErr_Occurred()) SWIG_fail;
21401 }
21402 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21403 return resultobj;
21404 fail:
21405 return NULL;
21406 }
21407
21408
21409 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21410 PyObject *resultobj;
21411 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21412 wxPoint *arg2 = 0 ;
21413 wxPoint temp2 ;
21414 PyObject * obj0 = 0 ;
21415 PyObject * obj1 = 0 ;
21416 char *kwnames[] = {
21417 (char *) "self",(char *) "pos", NULL
21418 };
21419
21420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21422 if (SWIG_arg_fail(1)) SWIG_fail;
21423 {
21424 arg2 = &temp2;
21425 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21426 }
21427 {
21428 PyThreadState* __tstate = wxPyBeginAllowThreads();
21429 (arg1)->SetPosition((wxPoint const &)*arg2);
21430
21431 wxPyEndAllowThreads(__tstate);
21432 if (PyErr_Occurred()) SWIG_fail;
21433 }
21434 Py_INCREF(Py_None); resultobj = Py_None;
21435 return resultobj;
21436 fail:
21437 return NULL;
21438 }
21439
21440
21441 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21442 PyObject *obj;
21443 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21444 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21445 Py_INCREF(obj);
21446 return Py_BuildValue((char *)"");
21447 }
21448 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21449 PyObject *resultobj;
21450 wxIdleEvent *result;
21451 char *kwnames[] = {
21452 NULL
21453 };
21454
21455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21456 {
21457 PyThreadState* __tstate = wxPyBeginAllowThreads();
21458 result = (wxIdleEvent *)new wxIdleEvent();
21459
21460 wxPyEndAllowThreads(__tstate);
21461 if (PyErr_Occurred()) SWIG_fail;
21462 }
21463 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21464 return resultobj;
21465 fail:
21466 return NULL;
21467 }
21468
21469
21470 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21471 PyObject *resultobj;
21472 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21473 bool arg2 = (bool) true ;
21474 PyObject * obj0 = 0 ;
21475 PyObject * obj1 = 0 ;
21476 char *kwnames[] = {
21477 (char *) "self",(char *) "needMore", NULL
21478 };
21479
21480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21482 if (SWIG_arg_fail(1)) SWIG_fail;
21483 if (obj1) {
21484 {
21485 arg2 = (bool)(SWIG_As_bool(obj1));
21486 if (SWIG_arg_fail(2)) SWIG_fail;
21487 }
21488 }
21489 {
21490 PyThreadState* __tstate = wxPyBeginAllowThreads();
21491 (arg1)->RequestMore(arg2);
21492
21493 wxPyEndAllowThreads(__tstate);
21494 if (PyErr_Occurred()) SWIG_fail;
21495 }
21496 Py_INCREF(Py_None); resultobj = Py_None;
21497 return resultobj;
21498 fail:
21499 return NULL;
21500 }
21501
21502
21503 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21504 PyObject *resultobj;
21505 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21506 bool result;
21507 PyObject * obj0 = 0 ;
21508 char *kwnames[] = {
21509 (char *) "self", NULL
21510 };
21511
21512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21514 if (SWIG_arg_fail(1)) SWIG_fail;
21515 {
21516 PyThreadState* __tstate = wxPyBeginAllowThreads();
21517 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21518
21519 wxPyEndAllowThreads(__tstate);
21520 if (PyErr_Occurred()) SWIG_fail;
21521 }
21522 {
21523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21524 }
21525 return resultobj;
21526 fail:
21527 return NULL;
21528 }
21529
21530
21531 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21532 PyObject *resultobj;
21533 wxIdleMode arg1 ;
21534 PyObject * obj0 = 0 ;
21535 char *kwnames[] = {
21536 (char *) "mode", NULL
21537 };
21538
21539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21540 {
21541 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21542 if (SWIG_arg_fail(1)) SWIG_fail;
21543 }
21544 {
21545 PyThreadState* __tstate = wxPyBeginAllowThreads();
21546 wxIdleEvent::SetMode((wxIdleMode )arg1);
21547
21548 wxPyEndAllowThreads(__tstate);
21549 if (PyErr_Occurred()) SWIG_fail;
21550 }
21551 Py_INCREF(Py_None); resultobj = Py_None;
21552 return resultobj;
21553 fail:
21554 return NULL;
21555 }
21556
21557
21558 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21559 PyObject *resultobj;
21560 wxIdleMode result;
21561 char *kwnames[] = {
21562 NULL
21563 };
21564
21565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21566 {
21567 PyThreadState* __tstate = wxPyBeginAllowThreads();
21568 result = (wxIdleMode)wxIdleEvent::GetMode();
21569
21570 wxPyEndAllowThreads(__tstate);
21571 if (PyErr_Occurred()) SWIG_fail;
21572 }
21573 resultobj = SWIG_From_int((result));
21574 return resultobj;
21575 fail:
21576 return NULL;
21577 }
21578
21579
21580 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
21581 PyObject *resultobj;
21582 wxWindow *arg1 = (wxWindow *) 0 ;
21583 bool result;
21584 PyObject * obj0 = 0 ;
21585 char *kwnames[] = {
21586 (char *) "win", NULL
21587 };
21588
21589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
21590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21591 if (SWIG_arg_fail(1)) SWIG_fail;
21592 {
21593 PyThreadState* __tstate = wxPyBeginAllowThreads();
21594 result = (bool)wxIdleEvent::CanSend(arg1);
21595
21596 wxPyEndAllowThreads(__tstate);
21597 if (PyErr_Occurred()) SWIG_fail;
21598 }
21599 {
21600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21601 }
21602 return resultobj;
21603 fail:
21604 return NULL;
21605 }
21606
21607
21608 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
21609 PyObject *obj;
21610 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21611 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
21612 Py_INCREF(obj);
21613 return Py_BuildValue((char *)"");
21614 }
21615 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21616 PyObject *resultobj;
21617 int arg1 = (int) 0 ;
21618 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
21619 wxPyEvent *result;
21620 PyObject * obj0 = 0 ;
21621 PyObject * obj1 = 0 ;
21622 char *kwnames[] = {
21623 (char *) "winid",(char *) "commandType", NULL
21624 };
21625
21626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
21627 if (obj0) {
21628 {
21629 arg1 = (int)(SWIG_As_int(obj0));
21630 if (SWIG_arg_fail(1)) SWIG_fail;
21631 }
21632 }
21633 if (obj1) {
21634 {
21635 arg2 = (wxEventType)(SWIG_As_int(obj1));
21636 if (SWIG_arg_fail(2)) SWIG_fail;
21637 }
21638 }
21639 {
21640 PyThreadState* __tstate = wxPyBeginAllowThreads();
21641 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
21642
21643 wxPyEndAllowThreads(__tstate);
21644 if (PyErr_Occurred()) SWIG_fail;
21645 }
21646 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
21647 return resultobj;
21648 fail:
21649 return NULL;
21650 }
21651
21652
21653 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21654 PyObject *resultobj;
21655 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21656 PyObject * obj0 = 0 ;
21657 char *kwnames[] = {
21658 (char *) "self", NULL
21659 };
21660
21661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
21662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21663 if (SWIG_arg_fail(1)) SWIG_fail;
21664 {
21665 PyThreadState* __tstate = wxPyBeginAllowThreads();
21666 delete arg1;
21667
21668 wxPyEndAllowThreads(__tstate);
21669 if (PyErr_Occurred()) SWIG_fail;
21670 }
21671 Py_INCREF(Py_None); resultobj = Py_None;
21672 return resultobj;
21673 fail:
21674 return NULL;
21675 }
21676
21677
21678 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21679 PyObject *resultobj;
21680 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21681 PyObject *arg2 = (PyObject *) 0 ;
21682 PyObject * obj0 = 0 ;
21683 PyObject * obj1 = 0 ;
21684 char *kwnames[] = {
21685 (char *) "self",(char *) "self", NULL
21686 };
21687
21688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21690 if (SWIG_arg_fail(1)) SWIG_fail;
21691 arg2 = obj1;
21692 {
21693 PyThreadState* __tstate = wxPyBeginAllowThreads();
21694 (arg1)->SetSelf(arg2);
21695
21696 wxPyEndAllowThreads(__tstate);
21697 if (PyErr_Occurred()) SWIG_fail;
21698 }
21699 Py_INCREF(Py_None); resultobj = Py_None;
21700 return resultobj;
21701 fail:
21702 return NULL;
21703 }
21704
21705
21706 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21707 PyObject *resultobj;
21708 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21709 PyObject *result;
21710 PyObject * obj0 = 0 ;
21711 char *kwnames[] = {
21712 (char *) "self", NULL
21713 };
21714
21715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
21716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21717 if (SWIG_arg_fail(1)) SWIG_fail;
21718 {
21719 PyThreadState* __tstate = wxPyBeginAllowThreads();
21720 result = (PyObject *)(arg1)->GetSelf();
21721
21722 wxPyEndAllowThreads(__tstate);
21723 if (PyErr_Occurred()) SWIG_fail;
21724 }
21725 resultobj = result;
21726 return resultobj;
21727 fail:
21728 return NULL;
21729 }
21730
21731
21732 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
21733 PyObject *obj;
21734 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21735 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
21736 Py_INCREF(obj);
21737 return Py_BuildValue((char *)"");
21738 }
21739 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21740 PyObject *resultobj;
21741 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21742 int arg2 = (int) 0 ;
21743 wxPyCommandEvent *result;
21744 PyObject * obj0 = 0 ;
21745 PyObject * obj1 = 0 ;
21746 char *kwnames[] = {
21747 (char *) "commandType",(char *) "id", NULL
21748 };
21749
21750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
21751 if (obj0) {
21752 {
21753 arg1 = (wxEventType)(SWIG_As_int(obj0));
21754 if (SWIG_arg_fail(1)) SWIG_fail;
21755 }
21756 }
21757 if (obj1) {
21758 {
21759 arg2 = (int)(SWIG_As_int(obj1));
21760 if (SWIG_arg_fail(2)) SWIG_fail;
21761 }
21762 }
21763 {
21764 PyThreadState* __tstate = wxPyBeginAllowThreads();
21765 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
21766
21767 wxPyEndAllowThreads(__tstate);
21768 if (PyErr_Occurred()) SWIG_fail;
21769 }
21770 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
21771 return resultobj;
21772 fail:
21773 return NULL;
21774 }
21775
21776
21777 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21778 PyObject *resultobj;
21779 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21780 PyObject * obj0 = 0 ;
21781 char *kwnames[] = {
21782 (char *) "self", NULL
21783 };
21784
21785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
21786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21787 if (SWIG_arg_fail(1)) SWIG_fail;
21788 {
21789 PyThreadState* __tstate = wxPyBeginAllowThreads();
21790 delete arg1;
21791
21792 wxPyEndAllowThreads(__tstate);
21793 if (PyErr_Occurred()) SWIG_fail;
21794 }
21795 Py_INCREF(Py_None); resultobj = Py_None;
21796 return resultobj;
21797 fail:
21798 return NULL;
21799 }
21800
21801
21802 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21803 PyObject *resultobj;
21804 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21805 PyObject *arg2 = (PyObject *) 0 ;
21806 PyObject * obj0 = 0 ;
21807 PyObject * obj1 = 0 ;
21808 char *kwnames[] = {
21809 (char *) "self",(char *) "self", NULL
21810 };
21811
21812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21814 if (SWIG_arg_fail(1)) SWIG_fail;
21815 arg2 = obj1;
21816 {
21817 PyThreadState* __tstate = wxPyBeginAllowThreads();
21818 (arg1)->SetSelf(arg2);
21819
21820 wxPyEndAllowThreads(__tstate);
21821 if (PyErr_Occurred()) SWIG_fail;
21822 }
21823 Py_INCREF(Py_None); resultobj = Py_None;
21824 return resultobj;
21825 fail:
21826 return NULL;
21827 }
21828
21829
21830 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21831 PyObject *resultobj;
21832 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21833 PyObject *result;
21834 PyObject * obj0 = 0 ;
21835 char *kwnames[] = {
21836 (char *) "self", NULL
21837 };
21838
21839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
21840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21841 if (SWIG_arg_fail(1)) SWIG_fail;
21842 {
21843 PyThreadState* __tstate = wxPyBeginAllowThreads();
21844 result = (PyObject *)(arg1)->GetSelf();
21845
21846 wxPyEndAllowThreads(__tstate);
21847 if (PyErr_Occurred()) SWIG_fail;
21848 }
21849 resultobj = result;
21850 return resultobj;
21851 fail:
21852 return NULL;
21853 }
21854
21855
21856 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
21857 PyObject *obj;
21858 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21859 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
21860 Py_INCREF(obj);
21861 return Py_BuildValue((char *)"");
21862 }
21863 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
21864 PyObject *resultobj;
21865 wxPyApp *result;
21866 char *kwnames[] = {
21867 NULL
21868 };
21869
21870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
21871 {
21872 PyThreadState* __tstate = wxPyBeginAllowThreads();
21873 result = (wxPyApp *)new_wxPyApp();
21874
21875 wxPyEndAllowThreads(__tstate);
21876 if (PyErr_Occurred()) SWIG_fail;
21877 }
21878 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
21879 return resultobj;
21880 fail:
21881 return NULL;
21882 }
21883
21884
21885 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
21886 PyObject *resultobj;
21887 wxPyApp *arg1 = (wxPyApp *) 0 ;
21888 PyObject * obj0 = 0 ;
21889 char *kwnames[] = {
21890 (char *) "self", NULL
21891 };
21892
21893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
21894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21895 if (SWIG_arg_fail(1)) SWIG_fail;
21896 {
21897 PyThreadState* __tstate = wxPyBeginAllowThreads();
21898 delete arg1;
21899
21900 wxPyEndAllowThreads(__tstate);
21901 if (PyErr_Occurred()) SWIG_fail;
21902 }
21903 Py_INCREF(Py_None); resultobj = Py_None;
21904 return resultobj;
21905 fail:
21906 return NULL;
21907 }
21908
21909
21910 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
21911 PyObject *resultobj;
21912 wxPyApp *arg1 = (wxPyApp *) 0 ;
21913 PyObject *arg2 = (PyObject *) 0 ;
21914 PyObject *arg3 = (PyObject *) 0 ;
21915 PyObject * obj0 = 0 ;
21916 PyObject * obj1 = 0 ;
21917 PyObject * obj2 = 0 ;
21918 char *kwnames[] = {
21919 (char *) "self",(char *) "self",(char *) "_class", NULL
21920 };
21921
21922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
21923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21924 if (SWIG_arg_fail(1)) SWIG_fail;
21925 arg2 = obj1;
21926 arg3 = obj2;
21927 {
21928 PyThreadState* __tstate = wxPyBeginAllowThreads();
21929 (arg1)->_setCallbackInfo(arg2,arg3);
21930
21931 wxPyEndAllowThreads(__tstate);
21932 if (PyErr_Occurred()) SWIG_fail;
21933 }
21934 Py_INCREF(Py_None); resultobj = Py_None;
21935 return resultobj;
21936 fail:
21937 return NULL;
21938 }
21939
21940
21941 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
21942 PyObject *resultobj;
21943 wxPyApp *arg1 = (wxPyApp *) 0 ;
21944 wxString result;
21945 PyObject * obj0 = 0 ;
21946 char *kwnames[] = {
21947 (char *) "self", NULL
21948 };
21949
21950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
21951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21952 if (SWIG_arg_fail(1)) SWIG_fail;
21953 {
21954 PyThreadState* __tstate = wxPyBeginAllowThreads();
21955 result = ((wxPyApp const *)arg1)->GetAppName();
21956
21957 wxPyEndAllowThreads(__tstate);
21958 if (PyErr_Occurred()) SWIG_fail;
21959 }
21960 {
21961 #if wxUSE_UNICODE
21962 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21963 #else
21964 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21965 #endif
21966 }
21967 return resultobj;
21968 fail:
21969 return NULL;
21970 }
21971
21972
21973 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
21974 PyObject *resultobj;
21975 wxPyApp *arg1 = (wxPyApp *) 0 ;
21976 wxString *arg2 = 0 ;
21977 bool temp2 = false ;
21978 PyObject * obj0 = 0 ;
21979 PyObject * obj1 = 0 ;
21980 char *kwnames[] = {
21981 (char *) "self",(char *) "name", NULL
21982 };
21983
21984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
21985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21986 if (SWIG_arg_fail(1)) SWIG_fail;
21987 {
21988 arg2 = wxString_in_helper(obj1);
21989 if (arg2 == NULL) SWIG_fail;
21990 temp2 = true;
21991 }
21992 {
21993 PyThreadState* __tstate = wxPyBeginAllowThreads();
21994 (arg1)->SetAppName((wxString const &)*arg2);
21995
21996 wxPyEndAllowThreads(__tstate);
21997 if (PyErr_Occurred()) SWIG_fail;
21998 }
21999 Py_INCREF(Py_None); resultobj = Py_None;
22000 {
22001 if (temp2)
22002 delete arg2;
22003 }
22004 return resultobj;
22005 fail:
22006 {
22007 if (temp2)
22008 delete arg2;
22009 }
22010 return NULL;
22011 }
22012
22013
22014 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22015 PyObject *resultobj;
22016 wxPyApp *arg1 = (wxPyApp *) 0 ;
22017 wxString result;
22018 PyObject * obj0 = 0 ;
22019 char *kwnames[] = {
22020 (char *) "self", NULL
22021 };
22022
22023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22025 if (SWIG_arg_fail(1)) SWIG_fail;
22026 {
22027 PyThreadState* __tstate = wxPyBeginAllowThreads();
22028 result = ((wxPyApp const *)arg1)->GetClassName();
22029
22030 wxPyEndAllowThreads(__tstate);
22031 if (PyErr_Occurred()) SWIG_fail;
22032 }
22033 {
22034 #if wxUSE_UNICODE
22035 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22036 #else
22037 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22038 #endif
22039 }
22040 return resultobj;
22041 fail:
22042 return NULL;
22043 }
22044
22045
22046 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22047 PyObject *resultobj;
22048 wxPyApp *arg1 = (wxPyApp *) 0 ;
22049 wxString *arg2 = 0 ;
22050 bool temp2 = false ;
22051 PyObject * obj0 = 0 ;
22052 PyObject * obj1 = 0 ;
22053 char *kwnames[] = {
22054 (char *) "self",(char *) "name", NULL
22055 };
22056
22057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22059 if (SWIG_arg_fail(1)) SWIG_fail;
22060 {
22061 arg2 = wxString_in_helper(obj1);
22062 if (arg2 == NULL) SWIG_fail;
22063 temp2 = true;
22064 }
22065 {
22066 PyThreadState* __tstate = wxPyBeginAllowThreads();
22067 (arg1)->SetClassName((wxString const &)*arg2);
22068
22069 wxPyEndAllowThreads(__tstate);
22070 if (PyErr_Occurred()) SWIG_fail;
22071 }
22072 Py_INCREF(Py_None); resultobj = Py_None;
22073 {
22074 if (temp2)
22075 delete arg2;
22076 }
22077 return resultobj;
22078 fail:
22079 {
22080 if (temp2)
22081 delete arg2;
22082 }
22083 return NULL;
22084 }
22085
22086
22087 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22088 PyObject *resultobj;
22089 wxPyApp *arg1 = (wxPyApp *) 0 ;
22090 wxString *result;
22091 PyObject * obj0 = 0 ;
22092 char *kwnames[] = {
22093 (char *) "self", NULL
22094 };
22095
22096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22098 if (SWIG_arg_fail(1)) SWIG_fail;
22099 {
22100 PyThreadState* __tstate = wxPyBeginAllowThreads();
22101 {
22102 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22103 result = (wxString *) &_result_ref;
22104 }
22105
22106 wxPyEndAllowThreads(__tstate);
22107 if (PyErr_Occurred()) SWIG_fail;
22108 }
22109 {
22110 #if wxUSE_UNICODE
22111 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22112 #else
22113 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22114 #endif
22115 }
22116 return resultobj;
22117 fail:
22118 return NULL;
22119 }
22120
22121
22122 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22123 PyObject *resultobj;
22124 wxPyApp *arg1 = (wxPyApp *) 0 ;
22125 wxString *arg2 = 0 ;
22126 bool temp2 = false ;
22127 PyObject * obj0 = 0 ;
22128 PyObject * obj1 = 0 ;
22129 char *kwnames[] = {
22130 (char *) "self",(char *) "name", NULL
22131 };
22132
22133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22135 if (SWIG_arg_fail(1)) SWIG_fail;
22136 {
22137 arg2 = wxString_in_helper(obj1);
22138 if (arg2 == NULL) SWIG_fail;
22139 temp2 = true;
22140 }
22141 {
22142 PyThreadState* __tstate = wxPyBeginAllowThreads();
22143 (arg1)->SetVendorName((wxString const &)*arg2);
22144
22145 wxPyEndAllowThreads(__tstate);
22146 if (PyErr_Occurred()) SWIG_fail;
22147 }
22148 Py_INCREF(Py_None); resultobj = Py_None;
22149 {
22150 if (temp2)
22151 delete arg2;
22152 }
22153 return resultobj;
22154 fail:
22155 {
22156 if (temp2)
22157 delete arg2;
22158 }
22159 return NULL;
22160 }
22161
22162
22163 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22164 PyObject *resultobj;
22165 wxPyApp *arg1 = (wxPyApp *) 0 ;
22166 wxAppTraits *result;
22167 PyObject * obj0 = 0 ;
22168 char *kwnames[] = {
22169 (char *) "self", NULL
22170 };
22171
22172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22174 if (SWIG_arg_fail(1)) SWIG_fail;
22175 {
22176 PyThreadState* __tstate = wxPyBeginAllowThreads();
22177 result = (wxAppTraits *)(arg1)->GetTraits();
22178
22179 wxPyEndAllowThreads(__tstate);
22180 if (PyErr_Occurred()) SWIG_fail;
22181 }
22182 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22183 return resultobj;
22184 fail:
22185 return NULL;
22186 }
22187
22188
22189 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22190 PyObject *resultobj;
22191 wxPyApp *arg1 = (wxPyApp *) 0 ;
22192 PyObject * obj0 = 0 ;
22193 char *kwnames[] = {
22194 (char *) "self", NULL
22195 };
22196
22197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22199 if (SWIG_arg_fail(1)) SWIG_fail;
22200 {
22201 PyThreadState* __tstate = wxPyBeginAllowThreads();
22202 (arg1)->ProcessPendingEvents();
22203
22204 wxPyEndAllowThreads(__tstate);
22205 if (PyErr_Occurred()) SWIG_fail;
22206 }
22207 Py_INCREF(Py_None); resultobj = Py_None;
22208 return resultobj;
22209 fail:
22210 return NULL;
22211 }
22212
22213
22214 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22215 PyObject *resultobj;
22216 wxPyApp *arg1 = (wxPyApp *) 0 ;
22217 bool arg2 = (bool) false ;
22218 bool result;
22219 PyObject * obj0 = 0 ;
22220 PyObject * obj1 = 0 ;
22221 char *kwnames[] = {
22222 (char *) "self",(char *) "onlyIfNeeded", NULL
22223 };
22224
22225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22227 if (SWIG_arg_fail(1)) SWIG_fail;
22228 if (obj1) {
22229 {
22230 arg2 = (bool)(SWIG_As_bool(obj1));
22231 if (SWIG_arg_fail(2)) SWIG_fail;
22232 }
22233 }
22234 {
22235 PyThreadState* __tstate = wxPyBeginAllowThreads();
22236 result = (bool)(arg1)->Yield(arg2);
22237
22238 wxPyEndAllowThreads(__tstate);
22239 if (PyErr_Occurred()) SWIG_fail;
22240 }
22241 {
22242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22243 }
22244 return resultobj;
22245 fail:
22246 return NULL;
22247 }
22248
22249
22250 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22251 PyObject *resultobj;
22252 wxPyApp *arg1 = (wxPyApp *) 0 ;
22253 PyObject * obj0 = 0 ;
22254 char *kwnames[] = {
22255 (char *) "self", NULL
22256 };
22257
22258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22260 if (SWIG_arg_fail(1)) SWIG_fail;
22261 {
22262 PyThreadState* __tstate = wxPyBeginAllowThreads();
22263 (arg1)->WakeUpIdle();
22264
22265 wxPyEndAllowThreads(__tstate);
22266 if (PyErr_Occurred()) SWIG_fail;
22267 }
22268 Py_INCREF(Py_None); resultobj = Py_None;
22269 return resultobj;
22270 fail:
22271 return NULL;
22272 }
22273
22274
22275 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22276 PyObject *resultobj;
22277 bool result;
22278 char *kwnames[] = {
22279 NULL
22280 };
22281
22282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22283 {
22284 PyThreadState* __tstate = wxPyBeginAllowThreads();
22285 result = (bool)wxPyApp::IsMainLoopRunning();
22286
22287 wxPyEndAllowThreads(__tstate);
22288 if (PyErr_Occurred()) SWIG_fail;
22289 }
22290 {
22291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22292 }
22293 return resultobj;
22294 fail:
22295 return NULL;
22296 }
22297
22298
22299 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22300 PyObject *resultobj;
22301 wxPyApp *arg1 = (wxPyApp *) 0 ;
22302 int result;
22303 PyObject * obj0 = 0 ;
22304 char *kwnames[] = {
22305 (char *) "self", NULL
22306 };
22307
22308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22310 if (SWIG_arg_fail(1)) SWIG_fail;
22311 {
22312 PyThreadState* __tstate = wxPyBeginAllowThreads();
22313 result = (int)(arg1)->MainLoop();
22314
22315 wxPyEndAllowThreads(__tstate);
22316 if (PyErr_Occurred()) SWIG_fail;
22317 }
22318 {
22319 resultobj = SWIG_From_int((int)(result));
22320 }
22321 return resultobj;
22322 fail:
22323 return NULL;
22324 }
22325
22326
22327 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22328 PyObject *resultobj;
22329 wxPyApp *arg1 = (wxPyApp *) 0 ;
22330 PyObject * obj0 = 0 ;
22331 char *kwnames[] = {
22332 (char *) "self", NULL
22333 };
22334
22335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22337 if (SWIG_arg_fail(1)) SWIG_fail;
22338 {
22339 PyThreadState* __tstate = wxPyBeginAllowThreads();
22340 (arg1)->Exit();
22341
22342 wxPyEndAllowThreads(__tstate);
22343 if (PyErr_Occurred()) SWIG_fail;
22344 }
22345 Py_INCREF(Py_None); resultobj = Py_None;
22346 return resultobj;
22347 fail:
22348 return NULL;
22349 }
22350
22351
22352 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22353 PyObject *resultobj;
22354 wxPyApp *arg1 = (wxPyApp *) 0 ;
22355 PyObject * obj0 = 0 ;
22356 char *kwnames[] = {
22357 (char *) "self", NULL
22358 };
22359
22360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22362 if (SWIG_arg_fail(1)) SWIG_fail;
22363 {
22364 PyThreadState* __tstate = wxPyBeginAllowThreads();
22365 (arg1)->ExitMainLoop();
22366
22367 wxPyEndAllowThreads(__tstate);
22368 if (PyErr_Occurred()) SWIG_fail;
22369 }
22370 Py_INCREF(Py_None); resultobj = Py_None;
22371 return resultobj;
22372 fail:
22373 return NULL;
22374 }
22375
22376
22377 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22378 PyObject *resultobj;
22379 wxPyApp *arg1 = (wxPyApp *) 0 ;
22380 bool result;
22381 PyObject * obj0 = 0 ;
22382 char *kwnames[] = {
22383 (char *) "self", NULL
22384 };
22385
22386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22388 if (SWIG_arg_fail(1)) SWIG_fail;
22389 {
22390 PyThreadState* __tstate = wxPyBeginAllowThreads();
22391 result = (bool)(arg1)->Pending();
22392
22393 wxPyEndAllowThreads(__tstate);
22394 if (PyErr_Occurred()) SWIG_fail;
22395 }
22396 {
22397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22398 }
22399 return resultobj;
22400 fail:
22401 return NULL;
22402 }
22403
22404
22405 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22406 PyObject *resultobj;
22407 wxPyApp *arg1 = (wxPyApp *) 0 ;
22408 bool result;
22409 PyObject * obj0 = 0 ;
22410 char *kwnames[] = {
22411 (char *) "self", NULL
22412 };
22413
22414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22416 if (SWIG_arg_fail(1)) SWIG_fail;
22417 {
22418 PyThreadState* __tstate = wxPyBeginAllowThreads();
22419 result = (bool)(arg1)->Dispatch();
22420
22421 wxPyEndAllowThreads(__tstate);
22422 if (PyErr_Occurred()) SWIG_fail;
22423 }
22424 {
22425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22426 }
22427 return resultobj;
22428 fail:
22429 return NULL;
22430 }
22431
22432
22433 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22434 PyObject *resultobj;
22435 wxPyApp *arg1 = (wxPyApp *) 0 ;
22436 bool result;
22437 PyObject * obj0 = 0 ;
22438 char *kwnames[] = {
22439 (char *) "self", NULL
22440 };
22441
22442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22444 if (SWIG_arg_fail(1)) SWIG_fail;
22445 {
22446 PyThreadState* __tstate = wxPyBeginAllowThreads();
22447 result = (bool)(arg1)->ProcessIdle();
22448
22449 wxPyEndAllowThreads(__tstate);
22450 if (PyErr_Occurred()) SWIG_fail;
22451 }
22452 {
22453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22454 }
22455 return resultobj;
22456 fail:
22457 return NULL;
22458 }
22459
22460
22461 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22462 PyObject *resultobj;
22463 wxPyApp *arg1 = (wxPyApp *) 0 ;
22464 wxWindow *arg2 = (wxWindow *) 0 ;
22465 wxIdleEvent *arg3 = 0 ;
22466 bool result;
22467 PyObject * obj0 = 0 ;
22468 PyObject * obj1 = 0 ;
22469 PyObject * obj2 = 0 ;
22470 char *kwnames[] = {
22471 (char *) "self",(char *) "win",(char *) "event", NULL
22472 };
22473
22474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
22475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22476 if (SWIG_arg_fail(1)) SWIG_fail;
22477 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22478 if (SWIG_arg_fail(2)) SWIG_fail;
22479 {
22480 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22481 if (SWIG_arg_fail(3)) SWIG_fail;
22482 if (arg3 == NULL) {
22483 SWIG_null_ref("wxIdleEvent");
22484 }
22485 if (SWIG_arg_fail(3)) SWIG_fail;
22486 }
22487 {
22488 PyThreadState* __tstate = wxPyBeginAllowThreads();
22489 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
22490
22491 wxPyEndAllowThreads(__tstate);
22492 if (PyErr_Occurred()) SWIG_fail;
22493 }
22494 {
22495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22496 }
22497 return resultobj;
22498 fail:
22499 return NULL;
22500 }
22501
22502
22503 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
22504 PyObject *resultobj;
22505 wxPyApp *arg1 = (wxPyApp *) 0 ;
22506 bool result;
22507 PyObject * obj0 = 0 ;
22508 char *kwnames[] = {
22509 (char *) "self", NULL
22510 };
22511
22512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
22513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22514 if (SWIG_arg_fail(1)) SWIG_fail;
22515 {
22516 PyThreadState* __tstate = wxPyBeginAllowThreads();
22517 result = (bool)((wxPyApp const *)arg1)->IsActive();
22518
22519 wxPyEndAllowThreads(__tstate);
22520 if (PyErr_Occurred()) SWIG_fail;
22521 }
22522 {
22523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22524 }
22525 return resultobj;
22526 fail:
22527 return NULL;
22528 }
22529
22530
22531 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22532 PyObject *resultobj;
22533 wxPyApp *arg1 = (wxPyApp *) 0 ;
22534 wxWindow *arg2 = (wxWindow *) 0 ;
22535 PyObject * obj0 = 0 ;
22536 PyObject * obj1 = 0 ;
22537 char *kwnames[] = {
22538 (char *) "self",(char *) "win", NULL
22539 };
22540
22541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
22542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22543 if (SWIG_arg_fail(1)) SWIG_fail;
22544 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22545 if (SWIG_arg_fail(2)) SWIG_fail;
22546 {
22547 PyThreadState* __tstate = wxPyBeginAllowThreads();
22548 (arg1)->SetTopWindow(arg2);
22549
22550 wxPyEndAllowThreads(__tstate);
22551 if (PyErr_Occurred()) SWIG_fail;
22552 }
22553 Py_INCREF(Py_None); resultobj = Py_None;
22554 return resultobj;
22555 fail:
22556 return NULL;
22557 }
22558
22559
22560 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22561 PyObject *resultobj;
22562 wxPyApp *arg1 = (wxPyApp *) 0 ;
22563 wxWindow *result;
22564 PyObject * obj0 = 0 ;
22565 char *kwnames[] = {
22566 (char *) "self", NULL
22567 };
22568
22569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
22570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22571 if (SWIG_arg_fail(1)) SWIG_fail;
22572 {
22573 PyThreadState* __tstate = wxPyBeginAllowThreads();
22574 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
22575
22576 wxPyEndAllowThreads(__tstate);
22577 if (PyErr_Occurred()) SWIG_fail;
22578 }
22579 {
22580 resultobj = wxPyMake_wxObject(result, 0);
22581 }
22582 return resultobj;
22583 fail:
22584 return NULL;
22585 }
22586
22587
22588 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22589 PyObject *resultobj;
22590 wxPyApp *arg1 = (wxPyApp *) 0 ;
22591 bool arg2 ;
22592 PyObject * obj0 = 0 ;
22593 PyObject * obj1 = 0 ;
22594 char *kwnames[] = {
22595 (char *) "self",(char *) "flag", NULL
22596 };
22597
22598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
22599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22600 if (SWIG_arg_fail(1)) SWIG_fail;
22601 {
22602 arg2 = (bool)(SWIG_As_bool(obj1));
22603 if (SWIG_arg_fail(2)) SWIG_fail;
22604 }
22605 {
22606 PyThreadState* __tstate = wxPyBeginAllowThreads();
22607 (arg1)->SetExitOnFrameDelete(arg2);
22608
22609 wxPyEndAllowThreads(__tstate);
22610 if (PyErr_Occurred()) SWIG_fail;
22611 }
22612 Py_INCREF(Py_None); resultobj = Py_None;
22613 return resultobj;
22614 fail:
22615 return NULL;
22616 }
22617
22618
22619 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22620 PyObject *resultobj;
22621 wxPyApp *arg1 = (wxPyApp *) 0 ;
22622 bool result;
22623 PyObject * obj0 = 0 ;
22624 char *kwnames[] = {
22625 (char *) "self", NULL
22626 };
22627
22628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
22629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22630 if (SWIG_arg_fail(1)) SWIG_fail;
22631 {
22632 PyThreadState* __tstate = wxPyBeginAllowThreads();
22633 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
22634
22635 wxPyEndAllowThreads(__tstate);
22636 if (PyErr_Occurred()) SWIG_fail;
22637 }
22638 {
22639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22640 }
22641 return resultobj;
22642 fail:
22643 return NULL;
22644 }
22645
22646
22647 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22648 PyObject *resultobj;
22649 wxPyApp *arg1 = (wxPyApp *) 0 ;
22650 bool arg2 ;
22651 PyObject * obj0 = 0 ;
22652 PyObject * obj1 = 0 ;
22653 char *kwnames[] = {
22654 (char *) "self",(char *) "flag", NULL
22655 };
22656
22657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
22658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22659 if (SWIG_arg_fail(1)) SWIG_fail;
22660 {
22661 arg2 = (bool)(SWIG_As_bool(obj1));
22662 if (SWIG_arg_fail(2)) SWIG_fail;
22663 }
22664 {
22665 PyThreadState* __tstate = wxPyBeginAllowThreads();
22666 (arg1)->SetUseBestVisual(arg2);
22667
22668 wxPyEndAllowThreads(__tstate);
22669 if (PyErr_Occurred()) SWIG_fail;
22670 }
22671 Py_INCREF(Py_None); resultobj = Py_None;
22672 return resultobj;
22673 fail:
22674 return NULL;
22675 }
22676
22677
22678 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22679 PyObject *resultobj;
22680 wxPyApp *arg1 = (wxPyApp *) 0 ;
22681 bool result;
22682 PyObject * obj0 = 0 ;
22683 char *kwnames[] = {
22684 (char *) "self", NULL
22685 };
22686
22687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
22688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22689 if (SWIG_arg_fail(1)) SWIG_fail;
22690 {
22691 PyThreadState* __tstate = wxPyBeginAllowThreads();
22692 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
22693
22694 wxPyEndAllowThreads(__tstate);
22695 if (PyErr_Occurred()) SWIG_fail;
22696 }
22697 {
22698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22699 }
22700 return resultobj;
22701 fail:
22702 return NULL;
22703 }
22704
22705
22706 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22707 PyObject *resultobj;
22708 wxPyApp *arg1 = (wxPyApp *) 0 ;
22709 int arg2 ;
22710 PyObject * obj0 = 0 ;
22711 PyObject * obj1 = 0 ;
22712 char *kwnames[] = {
22713 (char *) "self",(char *) "mode", NULL
22714 };
22715
22716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
22717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22718 if (SWIG_arg_fail(1)) SWIG_fail;
22719 {
22720 arg2 = (int)(SWIG_As_int(obj1));
22721 if (SWIG_arg_fail(2)) SWIG_fail;
22722 }
22723 {
22724 PyThreadState* __tstate = wxPyBeginAllowThreads();
22725 (arg1)->SetPrintMode(arg2);
22726
22727 wxPyEndAllowThreads(__tstate);
22728 if (PyErr_Occurred()) SWIG_fail;
22729 }
22730 Py_INCREF(Py_None); resultobj = Py_None;
22731 return resultobj;
22732 fail:
22733 return NULL;
22734 }
22735
22736
22737 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22738 PyObject *resultobj;
22739 wxPyApp *arg1 = (wxPyApp *) 0 ;
22740 int result;
22741 PyObject * obj0 = 0 ;
22742 char *kwnames[] = {
22743 (char *) "self", NULL
22744 };
22745
22746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
22747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22748 if (SWIG_arg_fail(1)) SWIG_fail;
22749 {
22750 PyThreadState* __tstate = wxPyBeginAllowThreads();
22751 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
22752
22753 wxPyEndAllowThreads(__tstate);
22754 if (PyErr_Occurred()) SWIG_fail;
22755 }
22756 {
22757 resultobj = SWIG_From_int((int)(result));
22758 }
22759 return resultobj;
22760 fail:
22761 return NULL;
22762 }
22763
22764
22765 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
22766 PyObject *resultobj;
22767 wxPyApp *arg1 = (wxPyApp *) 0 ;
22768 int arg2 ;
22769 PyObject * obj0 = 0 ;
22770 PyObject * obj1 = 0 ;
22771 char *kwnames[] = {
22772 (char *) "self",(char *) "mode", NULL
22773 };
22774
22775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
22776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22777 if (SWIG_arg_fail(1)) SWIG_fail;
22778 {
22779 arg2 = (int)(SWIG_As_int(obj1));
22780 if (SWIG_arg_fail(2)) SWIG_fail;
22781 }
22782 {
22783 PyThreadState* __tstate = wxPyBeginAllowThreads();
22784 (arg1)->SetAssertMode(arg2);
22785
22786 wxPyEndAllowThreads(__tstate);
22787 if (PyErr_Occurred()) SWIG_fail;
22788 }
22789 Py_INCREF(Py_None); resultobj = Py_None;
22790 return resultobj;
22791 fail:
22792 return NULL;
22793 }
22794
22795
22796 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
22797 PyObject *resultobj;
22798 wxPyApp *arg1 = (wxPyApp *) 0 ;
22799 int result;
22800 PyObject * obj0 = 0 ;
22801 char *kwnames[] = {
22802 (char *) "self", NULL
22803 };
22804
22805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
22806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22807 if (SWIG_arg_fail(1)) SWIG_fail;
22808 {
22809 PyThreadState* __tstate = wxPyBeginAllowThreads();
22810 result = (int)(arg1)->GetAssertMode();
22811
22812 wxPyEndAllowThreads(__tstate);
22813 if (PyErr_Occurred()) SWIG_fail;
22814 }
22815 {
22816 resultobj = SWIG_From_int((int)(result));
22817 }
22818 return resultobj;
22819 fail:
22820 return NULL;
22821 }
22822
22823
22824 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
22825 PyObject *resultobj;
22826 bool result;
22827 char *kwnames[] = {
22828 NULL
22829 };
22830
22831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
22832 {
22833 PyThreadState* __tstate = wxPyBeginAllowThreads();
22834 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
22835
22836 wxPyEndAllowThreads(__tstate);
22837 if (PyErr_Occurred()) SWIG_fail;
22838 }
22839 {
22840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22841 }
22842 return resultobj;
22843 fail:
22844 return NULL;
22845 }
22846
22847
22848 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22849 PyObject *resultobj;
22850 long result;
22851 char *kwnames[] = {
22852 NULL
22853 };
22854
22855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
22856 {
22857 PyThreadState* __tstate = wxPyBeginAllowThreads();
22858 result = (long)wxPyApp::GetMacAboutMenuItemId();
22859
22860 wxPyEndAllowThreads(__tstate);
22861 if (PyErr_Occurred()) SWIG_fail;
22862 }
22863 {
22864 resultobj = SWIG_From_long((long)(result));
22865 }
22866 return resultobj;
22867 fail:
22868 return NULL;
22869 }
22870
22871
22872 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22873 PyObject *resultobj;
22874 long result;
22875 char *kwnames[] = {
22876 NULL
22877 };
22878
22879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
22880 {
22881 PyThreadState* __tstate = wxPyBeginAllowThreads();
22882 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
22883
22884 wxPyEndAllowThreads(__tstate);
22885 if (PyErr_Occurred()) SWIG_fail;
22886 }
22887 {
22888 resultobj = SWIG_From_long((long)(result));
22889 }
22890 return resultobj;
22891 fail:
22892 return NULL;
22893 }
22894
22895
22896 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22897 PyObject *resultobj;
22898 long result;
22899 char *kwnames[] = {
22900 NULL
22901 };
22902
22903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
22904 {
22905 PyThreadState* __tstate = wxPyBeginAllowThreads();
22906 result = (long)wxPyApp::GetMacExitMenuItemId();
22907
22908 wxPyEndAllowThreads(__tstate);
22909 if (PyErr_Occurred()) SWIG_fail;
22910 }
22911 {
22912 resultobj = SWIG_From_long((long)(result));
22913 }
22914 return resultobj;
22915 fail:
22916 return NULL;
22917 }
22918
22919
22920 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
22921 PyObject *resultobj;
22922 wxString result;
22923 char *kwnames[] = {
22924 NULL
22925 };
22926
22927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
22928 {
22929 PyThreadState* __tstate = wxPyBeginAllowThreads();
22930 result = wxPyApp::GetMacHelpMenuTitleName();
22931
22932 wxPyEndAllowThreads(__tstate);
22933 if (PyErr_Occurred()) SWIG_fail;
22934 }
22935 {
22936 #if wxUSE_UNICODE
22937 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22938 #else
22939 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22940 #endif
22941 }
22942 return resultobj;
22943 fail:
22944 return NULL;
22945 }
22946
22947
22948 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
22949 PyObject *resultobj;
22950 bool arg1 ;
22951 PyObject * obj0 = 0 ;
22952 char *kwnames[] = {
22953 (char *) "val", NULL
22954 };
22955
22956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
22957 {
22958 arg1 = (bool)(SWIG_As_bool(obj0));
22959 if (SWIG_arg_fail(1)) SWIG_fail;
22960 }
22961 {
22962 PyThreadState* __tstate = wxPyBeginAllowThreads();
22963 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
22964
22965 wxPyEndAllowThreads(__tstate);
22966 if (PyErr_Occurred()) SWIG_fail;
22967 }
22968 Py_INCREF(Py_None); resultobj = Py_None;
22969 return resultobj;
22970 fail:
22971 return NULL;
22972 }
22973
22974
22975 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22976 PyObject *resultobj;
22977 long arg1 ;
22978 PyObject * obj0 = 0 ;
22979 char *kwnames[] = {
22980 (char *) "val", NULL
22981 };
22982
22983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
22984 {
22985 arg1 = (long)(SWIG_As_long(obj0));
22986 if (SWIG_arg_fail(1)) SWIG_fail;
22987 }
22988 {
22989 PyThreadState* __tstate = wxPyBeginAllowThreads();
22990 wxPyApp::SetMacAboutMenuItemId(arg1);
22991
22992 wxPyEndAllowThreads(__tstate);
22993 if (PyErr_Occurred()) SWIG_fail;
22994 }
22995 Py_INCREF(Py_None); resultobj = Py_None;
22996 return resultobj;
22997 fail:
22998 return NULL;
22999 }
23000
23001
23002 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23003 PyObject *resultobj;
23004 long arg1 ;
23005 PyObject * obj0 = 0 ;
23006 char *kwnames[] = {
23007 (char *) "val", NULL
23008 };
23009
23010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23011 {
23012 arg1 = (long)(SWIG_As_long(obj0));
23013 if (SWIG_arg_fail(1)) SWIG_fail;
23014 }
23015 {
23016 PyThreadState* __tstate = wxPyBeginAllowThreads();
23017 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23018
23019 wxPyEndAllowThreads(__tstate);
23020 if (PyErr_Occurred()) SWIG_fail;
23021 }
23022 Py_INCREF(Py_None); resultobj = Py_None;
23023 return resultobj;
23024 fail:
23025 return NULL;
23026 }
23027
23028
23029 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23030 PyObject *resultobj;
23031 long arg1 ;
23032 PyObject * obj0 = 0 ;
23033 char *kwnames[] = {
23034 (char *) "val", NULL
23035 };
23036
23037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23038 {
23039 arg1 = (long)(SWIG_As_long(obj0));
23040 if (SWIG_arg_fail(1)) SWIG_fail;
23041 }
23042 {
23043 PyThreadState* __tstate = wxPyBeginAllowThreads();
23044 wxPyApp::SetMacExitMenuItemId(arg1);
23045
23046 wxPyEndAllowThreads(__tstate);
23047 if (PyErr_Occurred()) SWIG_fail;
23048 }
23049 Py_INCREF(Py_None); resultobj = Py_None;
23050 return resultobj;
23051 fail:
23052 return NULL;
23053 }
23054
23055
23056 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23057 PyObject *resultobj;
23058 wxString *arg1 = 0 ;
23059 bool temp1 = false ;
23060 PyObject * obj0 = 0 ;
23061 char *kwnames[] = {
23062 (char *) "val", NULL
23063 };
23064
23065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23066 {
23067 arg1 = wxString_in_helper(obj0);
23068 if (arg1 == NULL) SWIG_fail;
23069 temp1 = true;
23070 }
23071 {
23072 PyThreadState* __tstate = wxPyBeginAllowThreads();
23073 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23074
23075 wxPyEndAllowThreads(__tstate);
23076 if (PyErr_Occurred()) SWIG_fail;
23077 }
23078 Py_INCREF(Py_None); resultobj = Py_None;
23079 {
23080 if (temp1)
23081 delete arg1;
23082 }
23083 return resultobj;
23084 fail:
23085 {
23086 if (temp1)
23087 delete arg1;
23088 }
23089 return NULL;
23090 }
23091
23092
23093 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23094 PyObject *resultobj;
23095 wxPyApp *arg1 = (wxPyApp *) 0 ;
23096 PyObject * obj0 = 0 ;
23097 char *kwnames[] = {
23098 (char *) "self", NULL
23099 };
23100
23101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23103 if (SWIG_arg_fail(1)) SWIG_fail;
23104 {
23105 PyThreadState* __tstate = wxPyBeginAllowThreads();
23106 (arg1)->_BootstrapApp();
23107
23108 wxPyEndAllowThreads(__tstate);
23109 if (PyErr_Occurred()) SWIG_fail;
23110 }
23111 Py_INCREF(Py_None); resultobj = Py_None;
23112 return resultobj;
23113 fail:
23114 return NULL;
23115 }
23116
23117
23118 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23119 PyObject *resultobj;
23120 int result;
23121 char *kwnames[] = {
23122 NULL
23123 };
23124
23125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23126 {
23127 PyThreadState* __tstate = wxPyBeginAllowThreads();
23128 result = (int)wxPyApp::GetComCtl32Version();
23129
23130 wxPyEndAllowThreads(__tstate);
23131 if (PyErr_Occurred()) SWIG_fail;
23132 }
23133 {
23134 resultobj = SWIG_From_int((int)(result));
23135 }
23136 return resultobj;
23137 fail:
23138 return NULL;
23139 }
23140
23141
23142 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23143 PyObject *obj;
23144 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23145 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23146 Py_INCREF(obj);
23147 return Py_BuildValue((char *)"");
23148 }
23149 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23150 PyObject *resultobj;
23151 char *kwnames[] = {
23152 NULL
23153 };
23154
23155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23156 {
23157 PyThreadState* __tstate = wxPyBeginAllowThreads();
23158 wxExit();
23159
23160 wxPyEndAllowThreads(__tstate);
23161 if (PyErr_Occurred()) SWIG_fail;
23162 }
23163 Py_INCREF(Py_None); resultobj = Py_None;
23164 return resultobj;
23165 fail:
23166 return NULL;
23167 }
23168
23169
23170 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23171 PyObject *resultobj;
23172 bool result;
23173 char *kwnames[] = {
23174 NULL
23175 };
23176
23177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23178 {
23179 PyThreadState* __tstate = wxPyBeginAllowThreads();
23180 result = (bool)wxYield();
23181
23182 wxPyEndAllowThreads(__tstate);
23183 if (PyErr_Occurred()) SWIG_fail;
23184 }
23185 {
23186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23187 }
23188 return resultobj;
23189 fail:
23190 return NULL;
23191 }
23192
23193
23194 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23195 PyObject *resultobj;
23196 bool result;
23197 char *kwnames[] = {
23198 NULL
23199 };
23200
23201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23202 {
23203 PyThreadState* __tstate = wxPyBeginAllowThreads();
23204 result = (bool)wxYieldIfNeeded();
23205
23206 wxPyEndAllowThreads(__tstate);
23207 if (PyErr_Occurred()) SWIG_fail;
23208 }
23209 {
23210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23211 }
23212 return resultobj;
23213 fail:
23214 return NULL;
23215 }
23216
23217
23218 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23219 PyObject *resultobj;
23220 wxWindow *arg1 = (wxWindow *) NULL ;
23221 bool arg2 = (bool) false ;
23222 bool result;
23223 PyObject * obj0 = 0 ;
23224 PyObject * obj1 = 0 ;
23225 char *kwnames[] = {
23226 (char *) "win",(char *) "onlyIfNeeded", NULL
23227 };
23228
23229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23230 if (obj0) {
23231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23232 if (SWIG_arg_fail(1)) SWIG_fail;
23233 }
23234 if (obj1) {
23235 {
23236 arg2 = (bool)(SWIG_As_bool(obj1));
23237 if (SWIG_arg_fail(2)) SWIG_fail;
23238 }
23239 }
23240 {
23241 PyThreadState* __tstate = wxPyBeginAllowThreads();
23242 result = (bool)wxSafeYield(arg1,arg2);
23243
23244 wxPyEndAllowThreads(__tstate);
23245 if (PyErr_Occurred()) SWIG_fail;
23246 }
23247 {
23248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23249 }
23250 return resultobj;
23251 fail:
23252 return NULL;
23253 }
23254
23255
23256 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23257 PyObject *resultobj;
23258 char *kwnames[] = {
23259 NULL
23260 };
23261
23262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23263 {
23264 PyThreadState* __tstate = wxPyBeginAllowThreads();
23265 wxWakeUpIdle();
23266
23267 wxPyEndAllowThreads(__tstate);
23268 if (PyErr_Occurred()) SWIG_fail;
23269 }
23270 Py_INCREF(Py_None); resultobj = Py_None;
23271 return resultobj;
23272 fail:
23273 return NULL;
23274 }
23275
23276
23277 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23278 PyObject *resultobj;
23279 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23280 wxEvent *arg2 = 0 ;
23281 PyObject * obj0 = 0 ;
23282 PyObject * obj1 = 0 ;
23283 char *kwnames[] = {
23284 (char *) "dest",(char *) "event", NULL
23285 };
23286
23287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23289 if (SWIG_arg_fail(1)) SWIG_fail;
23290 {
23291 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23292 if (SWIG_arg_fail(2)) SWIG_fail;
23293 if (arg2 == NULL) {
23294 SWIG_null_ref("wxEvent");
23295 }
23296 if (SWIG_arg_fail(2)) SWIG_fail;
23297 }
23298 {
23299 PyThreadState* __tstate = wxPyBeginAllowThreads();
23300 wxPostEvent(arg1,*arg2);
23301
23302 wxPyEndAllowThreads(__tstate);
23303 if (PyErr_Occurred()) SWIG_fail;
23304 }
23305 Py_INCREF(Py_None); resultobj = Py_None;
23306 return resultobj;
23307 fail:
23308 return NULL;
23309 }
23310
23311
23312 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23313 PyObject *resultobj;
23314 char *kwnames[] = {
23315 NULL
23316 };
23317
23318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23319 {
23320 PyThreadState* __tstate = wxPyBeginAllowThreads();
23321 wxApp_CleanUp();
23322
23323 wxPyEndAllowThreads(__tstate);
23324 if (PyErr_Occurred()) SWIG_fail;
23325 }
23326 Py_INCREF(Py_None); resultobj = Py_None;
23327 return resultobj;
23328 fail:
23329 return NULL;
23330 }
23331
23332
23333 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23334 PyObject *resultobj;
23335 wxPyApp *result;
23336 char *kwnames[] = {
23337 NULL
23338 };
23339
23340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23341 {
23342 PyThreadState* __tstate = wxPyBeginAllowThreads();
23343 result = (wxPyApp *)wxPyGetApp();
23344
23345 wxPyEndAllowThreads(__tstate);
23346 if (PyErr_Occurred()) SWIG_fail;
23347 }
23348 {
23349 resultobj = wxPyMake_wxObject(result, 0);
23350 }
23351 return resultobj;
23352 fail:
23353 return NULL;
23354 }
23355
23356
23357 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23358 PyObject *resultobj;
23359 char *arg1 = (char *) 0 ;
23360 PyObject * obj0 = 0 ;
23361 char *kwnames[] = {
23362 (char *) "encoding", NULL
23363 };
23364
23365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23366 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23367 SWIG_arg_fail(1);SWIG_fail;
23368 }
23369 {
23370 PyThreadState* __tstate = wxPyBeginAllowThreads();
23371 wxSetDefaultPyEncoding((char const *)arg1);
23372
23373 wxPyEndAllowThreads(__tstate);
23374 if (PyErr_Occurred()) SWIG_fail;
23375 }
23376 Py_INCREF(Py_None); resultobj = Py_None;
23377 return resultobj;
23378 fail:
23379 return NULL;
23380 }
23381
23382
23383 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23384 PyObject *resultobj;
23385 char *result;
23386 char *kwnames[] = {
23387 NULL
23388 };
23389
23390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23391 {
23392 PyThreadState* __tstate = wxPyBeginAllowThreads();
23393 result = (char *)wxGetDefaultPyEncoding();
23394
23395 wxPyEndAllowThreads(__tstate);
23396 if (PyErr_Occurred()) SWIG_fail;
23397 }
23398 resultobj = SWIG_FromCharPtr(result);
23399 return resultobj;
23400 fail:
23401 return NULL;
23402 }
23403
23404
23405 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23406 PyObject *resultobj;
23407 wxEventLoop *result;
23408 char *kwnames[] = {
23409 NULL
23410 };
23411
23412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23413 {
23414 PyThreadState* __tstate = wxPyBeginAllowThreads();
23415 result = (wxEventLoop *)new wxEventLoop();
23416
23417 wxPyEndAllowThreads(__tstate);
23418 if (PyErr_Occurred()) SWIG_fail;
23419 }
23420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23421 return resultobj;
23422 fail:
23423 return NULL;
23424 }
23425
23426
23427 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23428 PyObject *resultobj;
23429 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23430 PyObject * obj0 = 0 ;
23431 char *kwnames[] = {
23432 (char *) "self", NULL
23433 };
23434
23435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23437 if (SWIG_arg_fail(1)) SWIG_fail;
23438 {
23439 PyThreadState* __tstate = wxPyBeginAllowThreads();
23440 delete arg1;
23441
23442 wxPyEndAllowThreads(__tstate);
23443 if (PyErr_Occurred()) SWIG_fail;
23444 }
23445 Py_INCREF(Py_None); resultobj = Py_None;
23446 return resultobj;
23447 fail:
23448 return NULL;
23449 }
23450
23451
23452 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23453 PyObject *resultobj;
23454 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23455 int result;
23456 PyObject * obj0 = 0 ;
23457 char *kwnames[] = {
23458 (char *) "self", NULL
23459 };
23460
23461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
23462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23463 if (SWIG_arg_fail(1)) SWIG_fail;
23464 {
23465 PyThreadState* __tstate = wxPyBeginAllowThreads();
23466 result = (int)(arg1)->Run();
23467
23468 wxPyEndAllowThreads(__tstate);
23469 if (PyErr_Occurred()) SWIG_fail;
23470 }
23471 {
23472 resultobj = SWIG_From_int((int)(result));
23473 }
23474 return resultobj;
23475 fail:
23476 return NULL;
23477 }
23478
23479
23480 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23481 PyObject *resultobj;
23482 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23483 int arg2 = (int) 0 ;
23484 PyObject * obj0 = 0 ;
23485 PyObject * obj1 = 0 ;
23486 char *kwnames[] = {
23487 (char *) "self",(char *) "rc", NULL
23488 };
23489
23490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
23491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23492 if (SWIG_arg_fail(1)) SWIG_fail;
23493 if (obj1) {
23494 {
23495 arg2 = (int)(SWIG_As_int(obj1));
23496 if (SWIG_arg_fail(2)) SWIG_fail;
23497 }
23498 }
23499 {
23500 PyThreadState* __tstate = wxPyBeginAllowThreads();
23501 (arg1)->Exit(arg2);
23502
23503 wxPyEndAllowThreads(__tstate);
23504 if (PyErr_Occurred()) SWIG_fail;
23505 }
23506 Py_INCREF(Py_None); resultobj = Py_None;
23507 return resultobj;
23508 fail:
23509 return NULL;
23510 }
23511
23512
23513 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23514 PyObject *resultobj;
23515 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23516 bool result;
23517 PyObject * obj0 = 0 ;
23518 char *kwnames[] = {
23519 (char *) "self", NULL
23520 };
23521
23522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
23523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23524 if (SWIG_arg_fail(1)) SWIG_fail;
23525 {
23526 PyThreadState* __tstate = wxPyBeginAllowThreads();
23527 result = (bool)((wxEventLoop const *)arg1)->Pending();
23528
23529 wxPyEndAllowThreads(__tstate);
23530 if (PyErr_Occurred()) SWIG_fail;
23531 }
23532 {
23533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23534 }
23535 return resultobj;
23536 fail:
23537 return NULL;
23538 }
23539
23540
23541 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23542 PyObject *resultobj;
23543 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23544 bool result;
23545 PyObject * obj0 = 0 ;
23546 char *kwnames[] = {
23547 (char *) "self", NULL
23548 };
23549
23550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
23551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23552 if (SWIG_arg_fail(1)) SWIG_fail;
23553 {
23554 PyThreadState* __tstate = wxPyBeginAllowThreads();
23555 result = (bool)(arg1)->Dispatch();
23556
23557 wxPyEndAllowThreads(__tstate);
23558 if (PyErr_Occurred()) SWIG_fail;
23559 }
23560 {
23561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23562 }
23563 return resultobj;
23564 fail:
23565 return NULL;
23566 }
23567
23568
23569 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23570 PyObject *resultobj;
23571 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23572 bool result;
23573 PyObject * obj0 = 0 ;
23574 char *kwnames[] = {
23575 (char *) "self", NULL
23576 };
23577
23578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
23579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23580 if (SWIG_arg_fail(1)) SWIG_fail;
23581 {
23582 PyThreadState* __tstate = wxPyBeginAllowThreads();
23583 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
23584
23585 wxPyEndAllowThreads(__tstate);
23586 if (PyErr_Occurred()) SWIG_fail;
23587 }
23588 {
23589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23590 }
23591 return resultobj;
23592 fail:
23593 return NULL;
23594 }
23595
23596
23597 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23598 PyObject *resultobj;
23599 wxEventLoop *result;
23600 char *kwnames[] = {
23601 NULL
23602 };
23603
23604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
23605 {
23606 PyThreadState* __tstate = wxPyBeginAllowThreads();
23607 result = (wxEventLoop *)wxEventLoop::GetActive();
23608
23609 wxPyEndAllowThreads(__tstate);
23610 if (PyErr_Occurred()) SWIG_fail;
23611 }
23612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
23613 return resultobj;
23614 fail:
23615 return NULL;
23616 }
23617
23618
23619 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23620 PyObject *resultobj;
23621 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23622 PyObject * obj0 = 0 ;
23623 char *kwnames[] = {
23624 (char *) "loop", NULL
23625 };
23626
23627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
23628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23629 if (SWIG_arg_fail(1)) SWIG_fail;
23630 {
23631 PyThreadState* __tstate = wxPyBeginAllowThreads();
23632 wxEventLoop::SetActive(arg1);
23633
23634 wxPyEndAllowThreads(__tstate);
23635 if (PyErr_Occurred()) SWIG_fail;
23636 }
23637 Py_INCREF(Py_None); resultobj = Py_None;
23638 return resultobj;
23639 fail:
23640 return NULL;
23641 }
23642
23643
23644 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
23645 PyObject *obj;
23646 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23647 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
23648 Py_INCREF(obj);
23649 return Py_BuildValue((char *)"");
23650 }
23651 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23652 PyObject *resultobj;
23653 int arg1 = (int) 0 ;
23654 int arg2 = (int) 0 ;
23655 int arg3 = (int) 0 ;
23656 wxAcceleratorEntry *result;
23657 PyObject * obj0 = 0 ;
23658 PyObject * obj1 = 0 ;
23659 PyObject * obj2 = 0 ;
23660 char *kwnames[] = {
23661 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
23662 };
23663
23664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
23665 if (obj0) {
23666 {
23667 arg1 = (int)(SWIG_As_int(obj0));
23668 if (SWIG_arg_fail(1)) SWIG_fail;
23669 }
23670 }
23671 if (obj1) {
23672 {
23673 arg2 = (int)(SWIG_As_int(obj1));
23674 if (SWIG_arg_fail(2)) SWIG_fail;
23675 }
23676 }
23677 if (obj2) {
23678 {
23679 arg3 = (int)(SWIG_As_int(obj2));
23680 if (SWIG_arg_fail(3)) SWIG_fail;
23681 }
23682 }
23683 {
23684 PyThreadState* __tstate = wxPyBeginAllowThreads();
23685 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
23686
23687 wxPyEndAllowThreads(__tstate);
23688 if (PyErr_Occurred()) SWIG_fail;
23689 }
23690 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
23691 return resultobj;
23692 fail:
23693 return NULL;
23694 }
23695
23696
23697 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23698 PyObject *resultobj;
23699 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23700 PyObject * obj0 = 0 ;
23701 char *kwnames[] = {
23702 (char *) "self", NULL
23703 };
23704
23705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
23706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23707 if (SWIG_arg_fail(1)) SWIG_fail;
23708 {
23709 PyThreadState* __tstate = wxPyBeginAllowThreads();
23710 delete arg1;
23711
23712 wxPyEndAllowThreads(__tstate);
23713 if (PyErr_Occurred()) SWIG_fail;
23714 }
23715 Py_INCREF(Py_None); resultobj = Py_None;
23716 return resultobj;
23717 fail:
23718 return NULL;
23719 }
23720
23721
23722 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
23723 PyObject *resultobj;
23724 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23725 int arg2 ;
23726 int arg3 ;
23727 int arg4 ;
23728 PyObject * obj0 = 0 ;
23729 PyObject * obj1 = 0 ;
23730 PyObject * obj2 = 0 ;
23731 PyObject * obj3 = 0 ;
23732 char *kwnames[] = {
23733 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
23734 };
23735
23736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23738 if (SWIG_arg_fail(1)) SWIG_fail;
23739 {
23740 arg2 = (int)(SWIG_As_int(obj1));
23741 if (SWIG_arg_fail(2)) SWIG_fail;
23742 }
23743 {
23744 arg3 = (int)(SWIG_As_int(obj2));
23745 if (SWIG_arg_fail(3)) SWIG_fail;
23746 }
23747 {
23748 arg4 = (int)(SWIG_As_int(obj3));
23749 if (SWIG_arg_fail(4)) SWIG_fail;
23750 }
23751 {
23752 PyThreadState* __tstate = wxPyBeginAllowThreads();
23753 (arg1)->Set(arg2,arg3,arg4);
23754
23755 wxPyEndAllowThreads(__tstate);
23756 if (PyErr_Occurred()) SWIG_fail;
23757 }
23758 Py_INCREF(Py_None); resultobj = Py_None;
23759 return resultobj;
23760 fail:
23761 return NULL;
23762 }
23763
23764
23765 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
23766 PyObject *resultobj;
23767 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23768 int result;
23769 PyObject * obj0 = 0 ;
23770 char *kwnames[] = {
23771 (char *) "self", NULL
23772 };
23773
23774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
23775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23776 if (SWIG_arg_fail(1)) SWIG_fail;
23777 {
23778 PyThreadState* __tstate = wxPyBeginAllowThreads();
23779 result = (int)(arg1)->GetFlags();
23780
23781 wxPyEndAllowThreads(__tstate);
23782 if (PyErr_Occurred()) SWIG_fail;
23783 }
23784 {
23785 resultobj = SWIG_From_int((int)(result));
23786 }
23787 return resultobj;
23788 fail:
23789 return NULL;
23790 }
23791
23792
23793 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
23794 PyObject *resultobj;
23795 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23796 int result;
23797 PyObject * obj0 = 0 ;
23798 char *kwnames[] = {
23799 (char *) "self", NULL
23800 };
23801
23802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
23803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23804 if (SWIG_arg_fail(1)) SWIG_fail;
23805 {
23806 PyThreadState* __tstate = wxPyBeginAllowThreads();
23807 result = (int)(arg1)->GetKeyCode();
23808
23809 wxPyEndAllowThreads(__tstate);
23810 if (PyErr_Occurred()) SWIG_fail;
23811 }
23812 {
23813 resultobj = SWIG_From_int((int)(result));
23814 }
23815 return resultobj;
23816 fail:
23817 return NULL;
23818 }
23819
23820
23821 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
23822 PyObject *resultobj;
23823 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23824 int result;
23825 PyObject * obj0 = 0 ;
23826 char *kwnames[] = {
23827 (char *) "self", NULL
23828 };
23829
23830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
23831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23832 if (SWIG_arg_fail(1)) SWIG_fail;
23833 {
23834 PyThreadState* __tstate = wxPyBeginAllowThreads();
23835 result = (int)(arg1)->GetCommand();
23836
23837 wxPyEndAllowThreads(__tstate);
23838 if (PyErr_Occurred()) SWIG_fail;
23839 }
23840 {
23841 resultobj = SWIG_From_int((int)(result));
23842 }
23843 return resultobj;
23844 fail:
23845 return NULL;
23846 }
23847
23848
23849 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
23850 PyObject *obj;
23851 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23852 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
23853 Py_INCREF(obj);
23854 return Py_BuildValue((char *)"");
23855 }
23856 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
23857 PyObject *resultobj;
23858 int arg1 ;
23859 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
23860 wxAcceleratorTable *result;
23861 PyObject * obj0 = 0 ;
23862 char *kwnames[] = {
23863 (char *) "n", NULL
23864 };
23865
23866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
23867 {
23868 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
23869 if (arg2) arg1 = PyList_Size(obj0);
23870 else arg1 = 0;
23871 }
23872 {
23873 PyThreadState* __tstate = wxPyBeginAllowThreads();
23874 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
23875
23876 wxPyEndAllowThreads(__tstate);
23877 if (PyErr_Occurred()) SWIG_fail;
23878 }
23879 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
23880 {
23881 delete [] arg2;
23882 }
23883 return resultobj;
23884 fail:
23885 {
23886 delete [] arg2;
23887 }
23888 return NULL;
23889 }
23890
23891
23892 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
23893 PyObject *resultobj;
23894 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
23895 PyObject * obj0 = 0 ;
23896 char *kwnames[] = {
23897 (char *) "self", NULL
23898 };
23899
23900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
23901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
23902 if (SWIG_arg_fail(1)) SWIG_fail;
23903 {
23904 PyThreadState* __tstate = wxPyBeginAllowThreads();
23905 delete arg1;
23906
23907 wxPyEndAllowThreads(__tstate);
23908 if (PyErr_Occurred()) SWIG_fail;
23909 }
23910 Py_INCREF(Py_None); resultobj = Py_None;
23911 return resultobj;
23912 fail:
23913 return NULL;
23914 }
23915
23916
23917 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
23918 PyObject *resultobj;
23919 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
23920 bool result;
23921 PyObject * obj0 = 0 ;
23922 char *kwnames[] = {
23923 (char *) "self", NULL
23924 };
23925
23926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
23927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
23928 if (SWIG_arg_fail(1)) SWIG_fail;
23929 {
23930 PyThreadState* __tstate = wxPyBeginAllowThreads();
23931 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
23932
23933 wxPyEndAllowThreads(__tstate);
23934 if (PyErr_Occurred()) SWIG_fail;
23935 }
23936 {
23937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23938 }
23939 return resultobj;
23940 fail:
23941 return NULL;
23942 }
23943
23944
23945 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
23946 PyObject *obj;
23947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23948 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
23949 Py_INCREF(obj);
23950 return Py_BuildValue((char *)"");
23951 }
23952 static int _wrap_NullAcceleratorTable_set(PyObject *) {
23953 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
23954 return 1;
23955 }
23956
23957
23958 static PyObject *_wrap_NullAcceleratorTable_get(void) {
23959 PyObject *pyobj;
23960
23961 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
23962 return pyobj;
23963 }
23964
23965
23966 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
23967 PyObject *resultobj;
23968 wxString *arg1 = 0 ;
23969 wxAcceleratorEntry *result;
23970 bool temp1 = false ;
23971 PyObject * obj0 = 0 ;
23972 char *kwnames[] = {
23973 (char *) "label", NULL
23974 };
23975
23976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
23977 {
23978 arg1 = wxString_in_helper(obj0);
23979 if (arg1 == NULL) SWIG_fail;
23980 temp1 = true;
23981 }
23982 {
23983 PyThreadState* __tstate = wxPyBeginAllowThreads();
23984 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
23985
23986 wxPyEndAllowThreads(__tstate);
23987 if (PyErr_Occurred()) SWIG_fail;
23988 }
23989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
23990 {
23991 if (temp1)
23992 delete arg1;
23993 }
23994 return resultobj;
23995 fail:
23996 {
23997 if (temp1)
23998 delete arg1;
23999 }
24000 return NULL;
24001 }
24002
24003
24004 static int _wrap_PanelNameStr_set(PyObject *) {
24005 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24006 return 1;
24007 }
24008
24009
24010 static PyObject *_wrap_PanelNameStr_get(void) {
24011 PyObject *pyobj;
24012
24013 {
24014 #if wxUSE_UNICODE
24015 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24016 #else
24017 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24018 #endif
24019 }
24020 return pyobj;
24021 }
24022
24023
24024 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24025 PyObject *resultobj;
24026 wxVisualAttributes *result;
24027 char *kwnames[] = {
24028 NULL
24029 };
24030
24031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24032 {
24033 PyThreadState* __tstate = wxPyBeginAllowThreads();
24034 result = (wxVisualAttributes *)new_wxVisualAttributes();
24035
24036 wxPyEndAllowThreads(__tstate);
24037 if (PyErr_Occurred()) SWIG_fail;
24038 }
24039 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24040 return resultobj;
24041 fail:
24042 return NULL;
24043 }
24044
24045
24046 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24047 PyObject *resultobj;
24048 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24049 PyObject * obj0 = 0 ;
24050 char *kwnames[] = {
24051 (char *) "self", NULL
24052 };
24053
24054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24056 if (SWIG_arg_fail(1)) SWIG_fail;
24057 {
24058 PyThreadState* __tstate = wxPyBeginAllowThreads();
24059 delete_wxVisualAttributes(arg1);
24060
24061 wxPyEndAllowThreads(__tstate);
24062 if (PyErr_Occurred()) SWIG_fail;
24063 }
24064 Py_INCREF(Py_None); resultobj = Py_None;
24065 return resultobj;
24066 fail:
24067 return NULL;
24068 }
24069
24070
24071 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24072 PyObject *resultobj;
24073 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24074 wxFont *arg2 = (wxFont *) 0 ;
24075 PyObject * obj0 = 0 ;
24076 PyObject * obj1 = 0 ;
24077 char *kwnames[] = {
24078 (char *) "self",(char *) "font", NULL
24079 };
24080
24081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24083 if (SWIG_arg_fail(1)) SWIG_fail;
24084 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24085 if (SWIG_arg_fail(2)) SWIG_fail;
24086 if (arg1) (arg1)->font = *arg2;
24087
24088 Py_INCREF(Py_None); resultobj = Py_None;
24089 return resultobj;
24090 fail:
24091 return NULL;
24092 }
24093
24094
24095 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24096 PyObject *resultobj;
24097 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24098 wxFont *result;
24099 PyObject * obj0 = 0 ;
24100 char *kwnames[] = {
24101 (char *) "self", NULL
24102 };
24103
24104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24106 if (SWIG_arg_fail(1)) SWIG_fail;
24107 result = (wxFont *)& ((arg1)->font);
24108
24109 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24110 return resultobj;
24111 fail:
24112 return NULL;
24113 }
24114
24115
24116 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24117 PyObject *resultobj;
24118 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24119 wxColour *arg2 = (wxColour *) 0 ;
24120 PyObject * obj0 = 0 ;
24121 PyObject * obj1 = 0 ;
24122 char *kwnames[] = {
24123 (char *) "self",(char *) "colFg", NULL
24124 };
24125
24126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24128 if (SWIG_arg_fail(1)) SWIG_fail;
24129 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24130 if (SWIG_arg_fail(2)) SWIG_fail;
24131 if (arg1) (arg1)->colFg = *arg2;
24132
24133 Py_INCREF(Py_None); resultobj = Py_None;
24134 return resultobj;
24135 fail:
24136 return NULL;
24137 }
24138
24139
24140 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24141 PyObject *resultobj;
24142 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24143 wxColour *result;
24144 PyObject * obj0 = 0 ;
24145 char *kwnames[] = {
24146 (char *) "self", NULL
24147 };
24148
24149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24151 if (SWIG_arg_fail(1)) SWIG_fail;
24152 result = (wxColour *)& ((arg1)->colFg);
24153
24154 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24155 return resultobj;
24156 fail:
24157 return NULL;
24158 }
24159
24160
24161 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24162 PyObject *resultobj;
24163 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24164 wxColour *arg2 = (wxColour *) 0 ;
24165 PyObject * obj0 = 0 ;
24166 PyObject * obj1 = 0 ;
24167 char *kwnames[] = {
24168 (char *) "self",(char *) "colBg", NULL
24169 };
24170
24171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24173 if (SWIG_arg_fail(1)) SWIG_fail;
24174 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24175 if (SWIG_arg_fail(2)) SWIG_fail;
24176 if (arg1) (arg1)->colBg = *arg2;
24177
24178 Py_INCREF(Py_None); resultobj = Py_None;
24179 return resultobj;
24180 fail:
24181 return NULL;
24182 }
24183
24184
24185 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24186 PyObject *resultobj;
24187 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24188 wxColour *result;
24189 PyObject * obj0 = 0 ;
24190 char *kwnames[] = {
24191 (char *) "self", NULL
24192 };
24193
24194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24196 if (SWIG_arg_fail(1)) SWIG_fail;
24197 result = (wxColour *)& ((arg1)->colBg);
24198
24199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24200 return resultobj;
24201 fail:
24202 return NULL;
24203 }
24204
24205
24206 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24207 PyObject *obj;
24208 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24209 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24210 Py_INCREF(obj);
24211 return Py_BuildValue((char *)"");
24212 }
24213 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24214 PyObject *resultobj;
24215 wxWindow *arg1 = (wxWindow *) 0 ;
24216 int arg2 = (int) (int)-1 ;
24217 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24218 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24219 wxSize const &arg4_defvalue = wxDefaultSize ;
24220 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24221 long arg5 = (long) 0 ;
24222 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24223 wxString *arg6 = (wxString *) &arg6_defvalue ;
24224 wxWindow *result;
24225 wxPoint temp3 ;
24226 wxSize temp4 ;
24227 bool temp6 = false ;
24228 PyObject * obj0 = 0 ;
24229 PyObject * obj1 = 0 ;
24230 PyObject * obj2 = 0 ;
24231 PyObject * obj3 = 0 ;
24232 PyObject * obj4 = 0 ;
24233 PyObject * obj5 = 0 ;
24234 char *kwnames[] = {
24235 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24236 };
24237
24238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24240 if (SWIG_arg_fail(1)) SWIG_fail;
24241 if (obj1) {
24242 {
24243 arg2 = (int const)(SWIG_As_int(obj1));
24244 if (SWIG_arg_fail(2)) SWIG_fail;
24245 }
24246 }
24247 if (obj2) {
24248 {
24249 arg3 = &temp3;
24250 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24251 }
24252 }
24253 if (obj3) {
24254 {
24255 arg4 = &temp4;
24256 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24257 }
24258 }
24259 if (obj4) {
24260 {
24261 arg5 = (long)(SWIG_As_long(obj4));
24262 if (SWIG_arg_fail(5)) SWIG_fail;
24263 }
24264 }
24265 if (obj5) {
24266 {
24267 arg6 = wxString_in_helper(obj5);
24268 if (arg6 == NULL) SWIG_fail;
24269 temp6 = true;
24270 }
24271 }
24272 {
24273 if (!wxPyCheckForApp()) SWIG_fail;
24274 PyThreadState* __tstate = wxPyBeginAllowThreads();
24275 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24276
24277 wxPyEndAllowThreads(__tstate);
24278 if (PyErr_Occurred()) SWIG_fail;
24279 }
24280 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24281 {
24282 if (temp6)
24283 delete arg6;
24284 }
24285 return resultobj;
24286 fail:
24287 {
24288 if (temp6)
24289 delete arg6;
24290 }
24291 return NULL;
24292 }
24293
24294
24295 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24296 PyObject *resultobj;
24297 wxWindow *result;
24298 char *kwnames[] = {
24299 NULL
24300 };
24301
24302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24303 {
24304 if (!wxPyCheckForApp()) SWIG_fail;
24305 PyThreadState* __tstate = wxPyBeginAllowThreads();
24306 result = (wxWindow *)new wxWindow();
24307
24308 wxPyEndAllowThreads(__tstate);
24309 if (PyErr_Occurred()) SWIG_fail;
24310 }
24311 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24312 return resultobj;
24313 fail:
24314 return NULL;
24315 }
24316
24317
24318 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24319 PyObject *resultobj;
24320 wxWindow *arg1 = (wxWindow *) 0 ;
24321 wxWindow *arg2 = (wxWindow *) 0 ;
24322 int arg3 = (int) (int)-1 ;
24323 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24324 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24325 wxSize const &arg5_defvalue = wxDefaultSize ;
24326 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24327 long arg6 = (long) 0 ;
24328 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24329 wxString *arg7 = (wxString *) &arg7_defvalue ;
24330 bool result;
24331 wxPoint temp4 ;
24332 wxSize temp5 ;
24333 bool temp7 = false ;
24334 PyObject * obj0 = 0 ;
24335 PyObject * obj1 = 0 ;
24336 PyObject * obj2 = 0 ;
24337 PyObject * obj3 = 0 ;
24338 PyObject * obj4 = 0 ;
24339 PyObject * obj5 = 0 ;
24340 PyObject * obj6 = 0 ;
24341 char *kwnames[] = {
24342 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24343 };
24344
24345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24347 if (SWIG_arg_fail(1)) SWIG_fail;
24348 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24349 if (SWIG_arg_fail(2)) SWIG_fail;
24350 if (obj2) {
24351 {
24352 arg3 = (int const)(SWIG_As_int(obj2));
24353 if (SWIG_arg_fail(3)) SWIG_fail;
24354 }
24355 }
24356 if (obj3) {
24357 {
24358 arg4 = &temp4;
24359 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24360 }
24361 }
24362 if (obj4) {
24363 {
24364 arg5 = &temp5;
24365 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24366 }
24367 }
24368 if (obj5) {
24369 {
24370 arg6 = (long)(SWIG_As_long(obj5));
24371 if (SWIG_arg_fail(6)) SWIG_fail;
24372 }
24373 }
24374 if (obj6) {
24375 {
24376 arg7 = wxString_in_helper(obj6);
24377 if (arg7 == NULL) SWIG_fail;
24378 temp7 = true;
24379 }
24380 }
24381 {
24382 PyThreadState* __tstate = wxPyBeginAllowThreads();
24383 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24384
24385 wxPyEndAllowThreads(__tstate);
24386 if (PyErr_Occurred()) SWIG_fail;
24387 }
24388 {
24389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24390 }
24391 {
24392 if (temp7)
24393 delete arg7;
24394 }
24395 return resultobj;
24396 fail:
24397 {
24398 if (temp7)
24399 delete arg7;
24400 }
24401 return NULL;
24402 }
24403
24404
24405 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24406 PyObject *resultobj;
24407 wxWindow *arg1 = (wxWindow *) 0 ;
24408 bool arg2 = (bool) false ;
24409 bool result;
24410 PyObject * obj0 = 0 ;
24411 PyObject * obj1 = 0 ;
24412 char *kwnames[] = {
24413 (char *) "self",(char *) "force", NULL
24414 };
24415
24416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24418 if (SWIG_arg_fail(1)) SWIG_fail;
24419 if (obj1) {
24420 {
24421 arg2 = (bool)(SWIG_As_bool(obj1));
24422 if (SWIG_arg_fail(2)) SWIG_fail;
24423 }
24424 }
24425 {
24426 PyThreadState* __tstate = wxPyBeginAllowThreads();
24427 result = (bool)(arg1)->Close(arg2);
24428
24429 wxPyEndAllowThreads(__tstate);
24430 if (PyErr_Occurred()) SWIG_fail;
24431 }
24432 {
24433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24434 }
24435 return resultobj;
24436 fail:
24437 return NULL;
24438 }
24439
24440
24441 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24442 PyObject *resultobj;
24443 wxWindow *arg1 = (wxWindow *) 0 ;
24444 bool result;
24445 PyObject * obj0 = 0 ;
24446 char *kwnames[] = {
24447 (char *) "self", NULL
24448 };
24449
24450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24452 if (SWIG_arg_fail(1)) SWIG_fail;
24453 {
24454 PyThreadState* __tstate = wxPyBeginAllowThreads();
24455 result = (bool)(arg1)->Destroy();
24456
24457 wxPyEndAllowThreads(__tstate);
24458 if (PyErr_Occurred()) SWIG_fail;
24459 }
24460 {
24461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24462 }
24463 return resultobj;
24464 fail:
24465 return NULL;
24466 }
24467
24468
24469 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
24470 PyObject *resultobj;
24471 wxWindow *arg1 = (wxWindow *) 0 ;
24472 bool result;
24473 PyObject * obj0 = 0 ;
24474 char *kwnames[] = {
24475 (char *) "self", NULL
24476 };
24477
24478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
24479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24480 if (SWIG_arg_fail(1)) SWIG_fail;
24481 {
24482 PyThreadState* __tstate = wxPyBeginAllowThreads();
24483 result = (bool)(arg1)->DestroyChildren();
24484
24485 wxPyEndAllowThreads(__tstate);
24486 if (PyErr_Occurred()) SWIG_fail;
24487 }
24488 {
24489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24490 }
24491 return resultobj;
24492 fail:
24493 return NULL;
24494 }
24495
24496
24497 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
24498 PyObject *resultobj;
24499 wxWindow *arg1 = (wxWindow *) 0 ;
24500 bool result;
24501 PyObject * obj0 = 0 ;
24502 char *kwnames[] = {
24503 (char *) "self", NULL
24504 };
24505
24506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
24507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24508 if (SWIG_arg_fail(1)) SWIG_fail;
24509 {
24510 PyThreadState* __tstate = wxPyBeginAllowThreads();
24511 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
24512
24513 wxPyEndAllowThreads(__tstate);
24514 if (PyErr_Occurred()) SWIG_fail;
24515 }
24516 {
24517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24518 }
24519 return resultobj;
24520 fail:
24521 return NULL;
24522 }
24523
24524
24525 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24526 PyObject *resultobj;
24527 wxWindow *arg1 = (wxWindow *) 0 ;
24528 wxString *arg2 = 0 ;
24529 bool temp2 = false ;
24530 PyObject * obj0 = 0 ;
24531 PyObject * obj1 = 0 ;
24532 char *kwnames[] = {
24533 (char *) "self",(char *) "title", NULL
24534 };
24535
24536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
24537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24538 if (SWIG_arg_fail(1)) SWIG_fail;
24539 {
24540 arg2 = wxString_in_helper(obj1);
24541 if (arg2 == NULL) SWIG_fail;
24542 temp2 = true;
24543 }
24544 {
24545 PyThreadState* __tstate = wxPyBeginAllowThreads();
24546 (arg1)->SetTitle((wxString const &)*arg2);
24547
24548 wxPyEndAllowThreads(__tstate);
24549 if (PyErr_Occurred()) SWIG_fail;
24550 }
24551 Py_INCREF(Py_None); resultobj = Py_None;
24552 {
24553 if (temp2)
24554 delete arg2;
24555 }
24556 return resultobj;
24557 fail:
24558 {
24559 if (temp2)
24560 delete arg2;
24561 }
24562 return NULL;
24563 }
24564
24565
24566 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24567 PyObject *resultobj;
24568 wxWindow *arg1 = (wxWindow *) 0 ;
24569 wxString result;
24570 PyObject * obj0 = 0 ;
24571 char *kwnames[] = {
24572 (char *) "self", NULL
24573 };
24574
24575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
24576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24577 if (SWIG_arg_fail(1)) SWIG_fail;
24578 {
24579 PyThreadState* __tstate = wxPyBeginAllowThreads();
24580 result = ((wxWindow const *)arg1)->GetTitle();
24581
24582 wxPyEndAllowThreads(__tstate);
24583 if (PyErr_Occurred()) SWIG_fail;
24584 }
24585 {
24586 #if wxUSE_UNICODE
24587 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24588 #else
24589 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24590 #endif
24591 }
24592 return resultobj;
24593 fail:
24594 return NULL;
24595 }
24596
24597
24598 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24599 PyObject *resultobj;
24600 wxWindow *arg1 = (wxWindow *) 0 ;
24601 wxString *arg2 = 0 ;
24602 bool temp2 = false ;
24603 PyObject * obj0 = 0 ;
24604 PyObject * obj1 = 0 ;
24605 char *kwnames[] = {
24606 (char *) "self",(char *) "label", NULL
24607 };
24608
24609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
24610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24611 if (SWIG_arg_fail(1)) SWIG_fail;
24612 {
24613 arg2 = wxString_in_helper(obj1);
24614 if (arg2 == NULL) SWIG_fail;
24615 temp2 = true;
24616 }
24617 {
24618 PyThreadState* __tstate = wxPyBeginAllowThreads();
24619 (arg1)->SetLabel((wxString const &)*arg2);
24620
24621 wxPyEndAllowThreads(__tstate);
24622 if (PyErr_Occurred()) SWIG_fail;
24623 }
24624 Py_INCREF(Py_None); resultobj = Py_None;
24625 {
24626 if (temp2)
24627 delete arg2;
24628 }
24629 return resultobj;
24630 fail:
24631 {
24632 if (temp2)
24633 delete arg2;
24634 }
24635 return NULL;
24636 }
24637
24638
24639 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24640 PyObject *resultobj;
24641 wxWindow *arg1 = (wxWindow *) 0 ;
24642 wxString result;
24643 PyObject * obj0 = 0 ;
24644 char *kwnames[] = {
24645 (char *) "self", NULL
24646 };
24647
24648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
24649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24650 if (SWIG_arg_fail(1)) SWIG_fail;
24651 {
24652 PyThreadState* __tstate = wxPyBeginAllowThreads();
24653 result = ((wxWindow const *)arg1)->GetLabel();
24654
24655 wxPyEndAllowThreads(__tstate);
24656 if (PyErr_Occurred()) SWIG_fail;
24657 }
24658 {
24659 #if wxUSE_UNICODE
24660 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24661 #else
24662 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24663 #endif
24664 }
24665 return resultobj;
24666 fail:
24667 return NULL;
24668 }
24669
24670
24671 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
24672 PyObject *resultobj;
24673 wxWindow *arg1 = (wxWindow *) 0 ;
24674 wxString *arg2 = 0 ;
24675 bool temp2 = false ;
24676 PyObject * obj0 = 0 ;
24677 PyObject * obj1 = 0 ;
24678 char *kwnames[] = {
24679 (char *) "self",(char *) "name", NULL
24680 };
24681
24682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
24683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24684 if (SWIG_arg_fail(1)) SWIG_fail;
24685 {
24686 arg2 = wxString_in_helper(obj1);
24687 if (arg2 == NULL) SWIG_fail;
24688 temp2 = true;
24689 }
24690 {
24691 PyThreadState* __tstate = wxPyBeginAllowThreads();
24692 (arg1)->SetName((wxString const &)*arg2);
24693
24694 wxPyEndAllowThreads(__tstate);
24695 if (PyErr_Occurred()) SWIG_fail;
24696 }
24697 Py_INCREF(Py_None); resultobj = Py_None;
24698 {
24699 if (temp2)
24700 delete arg2;
24701 }
24702 return resultobj;
24703 fail:
24704 {
24705 if (temp2)
24706 delete arg2;
24707 }
24708 return NULL;
24709 }
24710
24711
24712 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
24713 PyObject *resultobj;
24714 wxWindow *arg1 = (wxWindow *) 0 ;
24715 wxString result;
24716 PyObject * obj0 = 0 ;
24717 char *kwnames[] = {
24718 (char *) "self", NULL
24719 };
24720
24721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
24722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24723 if (SWIG_arg_fail(1)) SWIG_fail;
24724 {
24725 PyThreadState* __tstate = wxPyBeginAllowThreads();
24726 result = ((wxWindow const *)arg1)->GetName();
24727
24728 wxPyEndAllowThreads(__tstate);
24729 if (PyErr_Occurred()) SWIG_fail;
24730 }
24731 {
24732 #if wxUSE_UNICODE
24733 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24734 #else
24735 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24736 #endif
24737 }
24738 return resultobj;
24739 fail:
24740 return NULL;
24741 }
24742
24743
24744 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
24745 PyObject *resultobj;
24746 wxWindow *arg1 = (wxWindow *) 0 ;
24747 wxWindowVariant arg2 ;
24748 PyObject * obj0 = 0 ;
24749 PyObject * obj1 = 0 ;
24750 char *kwnames[] = {
24751 (char *) "self",(char *) "variant", NULL
24752 };
24753
24754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
24755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24756 if (SWIG_arg_fail(1)) SWIG_fail;
24757 {
24758 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
24759 if (SWIG_arg_fail(2)) SWIG_fail;
24760 }
24761 {
24762 PyThreadState* __tstate = wxPyBeginAllowThreads();
24763 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
24764
24765 wxPyEndAllowThreads(__tstate);
24766 if (PyErr_Occurred()) SWIG_fail;
24767 }
24768 Py_INCREF(Py_None); resultobj = Py_None;
24769 return resultobj;
24770 fail:
24771 return NULL;
24772 }
24773
24774
24775 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
24776 PyObject *resultobj;
24777 wxWindow *arg1 = (wxWindow *) 0 ;
24778 wxWindowVariant result;
24779 PyObject * obj0 = 0 ;
24780 char *kwnames[] = {
24781 (char *) "self", NULL
24782 };
24783
24784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
24785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24786 if (SWIG_arg_fail(1)) SWIG_fail;
24787 {
24788 PyThreadState* __tstate = wxPyBeginAllowThreads();
24789 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
24790
24791 wxPyEndAllowThreads(__tstate);
24792 if (PyErr_Occurred()) SWIG_fail;
24793 }
24794 resultobj = SWIG_From_int((result));
24795 return resultobj;
24796 fail:
24797 return NULL;
24798 }
24799
24800
24801 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
24802 PyObject *resultobj;
24803 wxWindow *arg1 = (wxWindow *) 0 ;
24804 int arg2 ;
24805 PyObject * obj0 = 0 ;
24806 PyObject * obj1 = 0 ;
24807 char *kwnames[] = {
24808 (char *) "self",(char *) "winid", NULL
24809 };
24810
24811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
24812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24813 if (SWIG_arg_fail(1)) SWIG_fail;
24814 {
24815 arg2 = (int)(SWIG_As_int(obj1));
24816 if (SWIG_arg_fail(2)) SWIG_fail;
24817 }
24818 {
24819 PyThreadState* __tstate = wxPyBeginAllowThreads();
24820 (arg1)->SetId(arg2);
24821
24822 wxPyEndAllowThreads(__tstate);
24823 if (PyErr_Occurred()) SWIG_fail;
24824 }
24825 Py_INCREF(Py_None); resultobj = Py_None;
24826 return resultobj;
24827 fail:
24828 return NULL;
24829 }
24830
24831
24832 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
24833 PyObject *resultobj;
24834 wxWindow *arg1 = (wxWindow *) 0 ;
24835 int result;
24836 PyObject * obj0 = 0 ;
24837 char *kwnames[] = {
24838 (char *) "self", NULL
24839 };
24840
24841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
24842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24843 if (SWIG_arg_fail(1)) SWIG_fail;
24844 {
24845 PyThreadState* __tstate = wxPyBeginAllowThreads();
24846 result = (int)((wxWindow const *)arg1)->GetId();
24847
24848 wxPyEndAllowThreads(__tstate);
24849 if (PyErr_Occurred()) SWIG_fail;
24850 }
24851 {
24852 resultobj = SWIG_From_int((int)(result));
24853 }
24854 return resultobj;
24855 fail:
24856 return NULL;
24857 }
24858
24859
24860 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24861 PyObject *resultobj;
24862 int result;
24863 char *kwnames[] = {
24864 NULL
24865 };
24866
24867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
24868 {
24869 PyThreadState* __tstate = wxPyBeginAllowThreads();
24870 result = (int)wxWindow::NewControlId();
24871
24872 wxPyEndAllowThreads(__tstate);
24873 if (PyErr_Occurred()) SWIG_fail;
24874 }
24875 {
24876 resultobj = SWIG_From_int((int)(result));
24877 }
24878 return resultobj;
24879 fail:
24880 return NULL;
24881 }
24882
24883
24884 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24885 PyObject *resultobj;
24886 int arg1 ;
24887 int result;
24888 PyObject * obj0 = 0 ;
24889 char *kwnames[] = {
24890 (char *) "winid", NULL
24891 };
24892
24893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
24894 {
24895 arg1 = (int)(SWIG_As_int(obj0));
24896 if (SWIG_arg_fail(1)) SWIG_fail;
24897 }
24898 {
24899 PyThreadState* __tstate = wxPyBeginAllowThreads();
24900 result = (int)wxWindow::NextControlId(arg1);
24901
24902 wxPyEndAllowThreads(__tstate);
24903 if (PyErr_Occurred()) SWIG_fail;
24904 }
24905 {
24906 resultobj = SWIG_From_int((int)(result));
24907 }
24908 return resultobj;
24909 fail:
24910 return NULL;
24911 }
24912
24913
24914 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24915 PyObject *resultobj;
24916 int arg1 ;
24917 int result;
24918 PyObject * obj0 = 0 ;
24919 char *kwnames[] = {
24920 (char *) "winid", NULL
24921 };
24922
24923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
24924 {
24925 arg1 = (int)(SWIG_As_int(obj0));
24926 if (SWIG_arg_fail(1)) SWIG_fail;
24927 }
24928 {
24929 PyThreadState* __tstate = wxPyBeginAllowThreads();
24930 result = (int)wxWindow::PrevControlId(arg1);
24931
24932 wxPyEndAllowThreads(__tstate);
24933 if (PyErr_Occurred()) SWIG_fail;
24934 }
24935 {
24936 resultobj = SWIG_From_int((int)(result));
24937 }
24938 return resultobj;
24939 fail:
24940 return NULL;
24941 }
24942
24943
24944 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
24945 PyObject *resultobj;
24946 wxWindow *arg1 = (wxWindow *) 0 ;
24947 wxSize *arg2 = 0 ;
24948 wxSize temp2 ;
24949 PyObject * obj0 = 0 ;
24950 PyObject * obj1 = 0 ;
24951 char *kwnames[] = {
24952 (char *) "self",(char *) "size", NULL
24953 };
24954
24955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
24956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24957 if (SWIG_arg_fail(1)) SWIG_fail;
24958 {
24959 arg2 = &temp2;
24960 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
24961 }
24962 {
24963 PyThreadState* __tstate = wxPyBeginAllowThreads();
24964 (arg1)->SetSize((wxSize const &)*arg2);
24965
24966 wxPyEndAllowThreads(__tstate);
24967 if (PyErr_Occurred()) SWIG_fail;
24968 }
24969 Py_INCREF(Py_None); resultobj = Py_None;
24970 return resultobj;
24971 fail:
24972 return NULL;
24973 }
24974
24975
24976 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
24977 PyObject *resultobj;
24978 wxWindow *arg1 = (wxWindow *) 0 ;
24979 int arg2 ;
24980 int arg3 ;
24981 int arg4 ;
24982 int arg5 ;
24983 int arg6 = (int) wxSIZE_AUTO ;
24984 PyObject * obj0 = 0 ;
24985 PyObject * obj1 = 0 ;
24986 PyObject * obj2 = 0 ;
24987 PyObject * obj3 = 0 ;
24988 PyObject * obj4 = 0 ;
24989 PyObject * obj5 = 0 ;
24990 char *kwnames[] = {
24991 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
24992 };
24993
24994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24996 if (SWIG_arg_fail(1)) SWIG_fail;
24997 {
24998 arg2 = (int)(SWIG_As_int(obj1));
24999 if (SWIG_arg_fail(2)) SWIG_fail;
25000 }
25001 {
25002 arg3 = (int)(SWIG_As_int(obj2));
25003 if (SWIG_arg_fail(3)) SWIG_fail;
25004 }
25005 {
25006 arg4 = (int)(SWIG_As_int(obj3));
25007 if (SWIG_arg_fail(4)) SWIG_fail;
25008 }
25009 {
25010 arg5 = (int)(SWIG_As_int(obj4));
25011 if (SWIG_arg_fail(5)) SWIG_fail;
25012 }
25013 if (obj5) {
25014 {
25015 arg6 = (int)(SWIG_As_int(obj5));
25016 if (SWIG_arg_fail(6)) SWIG_fail;
25017 }
25018 }
25019 {
25020 PyThreadState* __tstate = wxPyBeginAllowThreads();
25021 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25022
25023 wxPyEndAllowThreads(__tstate);
25024 if (PyErr_Occurred()) SWIG_fail;
25025 }
25026 Py_INCREF(Py_None); resultobj = Py_None;
25027 return resultobj;
25028 fail:
25029 return NULL;
25030 }
25031
25032
25033 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25034 PyObject *resultobj;
25035 wxWindow *arg1 = (wxWindow *) 0 ;
25036 wxRect *arg2 = 0 ;
25037 int arg3 = (int) wxSIZE_AUTO ;
25038 wxRect temp2 ;
25039 PyObject * obj0 = 0 ;
25040 PyObject * obj1 = 0 ;
25041 PyObject * obj2 = 0 ;
25042 char *kwnames[] = {
25043 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25044 };
25045
25046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25048 if (SWIG_arg_fail(1)) SWIG_fail;
25049 {
25050 arg2 = &temp2;
25051 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25052 }
25053 if (obj2) {
25054 {
25055 arg3 = (int)(SWIG_As_int(obj2));
25056 if (SWIG_arg_fail(3)) SWIG_fail;
25057 }
25058 }
25059 {
25060 PyThreadState* __tstate = wxPyBeginAllowThreads();
25061 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25062
25063 wxPyEndAllowThreads(__tstate);
25064 if (PyErr_Occurred()) SWIG_fail;
25065 }
25066 Py_INCREF(Py_None); resultobj = Py_None;
25067 return resultobj;
25068 fail:
25069 return NULL;
25070 }
25071
25072
25073 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25074 PyObject *resultobj;
25075 wxWindow *arg1 = (wxWindow *) 0 ;
25076 int arg2 ;
25077 int arg3 ;
25078 PyObject * obj0 = 0 ;
25079 PyObject * obj1 = 0 ;
25080 PyObject * obj2 = 0 ;
25081 char *kwnames[] = {
25082 (char *) "self",(char *) "width",(char *) "height", NULL
25083 };
25084
25085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25087 if (SWIG_arg_fail(1)) SWIG_fail;
25088 {
25089 arg2 = (int)(SWIG_As_int(obj1));
25090 if (SWIG_arg_fail(2)) SWIG_fail;
25091 }
25092 {
25093 arg3 = (int)(SWIG_As_int(obj2));
25094 if (SWIG_arg_fail(3)) SWIG_fail;
25095 }
25096 {
25097 PyThreadState* __tstate = wxPyBeginAllowThreads();
25098 (arg1)->SetSize(arg2,arg3);
25099
25100 wxPyEndAllowThreads(__tstate);
25101 if (PyErr_Occurred()) SWIG_fail;
25102 }
25103 Py_INCREF(Py_None); resultobj = Py_None;
25104 return resultobj;
25105 fail:
25106 return NULL;
25107 }
25108
25109
25110 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25111 PyObject *resultobj;
25112 wxWindow *arg1 = (wxWindow *) 0 ;
25113 wxPoint *arg2 = 0 ;
25114 int arg3 = (int) wxSIZE_USE_EXISTING ;
25115 wxPoint temp2 ;
25116 PyObject * obj0 = 0 ;
25117 PyObject * obj1 = 0 ;
25118 PyObject * obj2 = 0 ;
25119 char *kwnames[] = {
25120 (char *) "self",(char *) "pt",(char *) "flags", NULL
25121 };
25122
25123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25125 if (SWIG_arg_fail(1)) SWIG_fail;
25126 {
25127 arg2 = &temp2;
25128 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25129 }
25130 if (obj2) {
25131 {
25132 arg3 = (int)(SWIG_As_int(obj2));
25133 if (SWIG_arg_fail(3)) SWIG_fail;
25134 }
25135 }
25136 {
25137 PyThreadState* __tstate = wxPyBeginAllowThreads();
25138 (arg1)->Move((wxPoint const &)*arg2,arg3);
25139
25140 wxPyEndAllowThreads(__tstate);
25141 if (PyErr_Occurred()) SWIG_fail;
25142 }
25143 Py_INCREF(Py_None); resultobj = Py_None;
25144 return resultobj;
25145 fail:
25146 return NULL;
25147 }
25148
25149
25150 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25151 PyObject *resultobj;
25152 wxWindow *arg1 = (wxWindow *) 0 ;
25153 int arg2 ;
25154 int arg3 ;
25155 int arg4 = (int) wxSIZE_USE_EXISTING ;
25156 PyObject * obj0 = 0 ;
25157 PyObject * obj1 = 0 ;
25158 PyObject * obj2 = 0 ;
25159 PyObject * obj3 = 0 ;
25160 char *kwnames[] = {
25161 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25162 };
25163
25164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25166 if (SWIG_arg_fail(1)) SWIG_fail;
25167 {
25168 arg2 = (int)(SWIG_As_int(obj1));
25169 if (SWIG_arg_fail(2)) SWIG_fail;
25170 }
25171 {
25172 arg3 = (int)(SWIG_As_int(obj2));
25173 if (SWIG_arg_fail(3)) SWIG_fail;
25174 }
25175 if (obj3) {
25176 {
25177 arg4 = (int)(SWIG_As_int(obj3));
25178 if (SWIG_arg_fail(4)) SWIG_fail;
25179 }
25180 }
25181 {
25182 PyThreadState* __tstate = wxPyBeginAllowThreads();
25183 (arg1)->Move(arg2,arg3,arg4);
25184
25185 wxPyEndAllowThreads(__tstate);
25186 if (PyErr_Occurred()) SWIG_fail;
25187 }
25188 Py_INCREF(Py_None); resultobj = Py_None;
25189 return resultobj;
25190 fail:
25191 return NULL;
25192 }
25193
25194
25195 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25196 PyObject *resultobj;
25197 wxWindow *arg1 = (wxWindow *) 0 ;
25198 wxSize const &arg2_defvalue = wxDefaultSize ;
25199 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25200 wxSize temp2 ;
25201 PyObject * obj0 = 0 ;
25202 PyObject * obj1 = 0 ;
25203 char *kwnames[] = {
25204 (char *) "self",(char *) "size", NULL
25205 };
25206
25207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25209 if (SWIG_arg_fail(1)) SWIG_fail;
25210 if (obj1) {
25211 {
25212 arg2 = &temp2;
25213 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25214 }
25215 }
25216 {
25217 PyThreadState* __tstate = wxPyBeginAllowThreads();
25218 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25219
25220 wxPyEndAllowThreads(__tstate);
25221 if (PyErr_Occurred()) SWIG_fail;
25222 }
25223 Py_INCREF(Py_None); resultobj = Py_None;
25224 return resultobj;
25225 fail:
25226 return NULL;
25227 }
25228
25229
25230 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25231 PyObject *resultobj;
25232 wxWindow *arg1 = (wxWindow *) 0 ;
25233 PyObject * obj0 = 0 ;
25234 char *kwnames[] = {
25235 (char *) "self", NULL
25236 };
25237
25238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25240 if (SWIG_arg_fail(1)) SWIG_fail;
25241 {
25242 PyThreadState* __tstate = wxPyBeginAllowThreads();
25243 (arg1)->Raise();
25244
25245 wxPyEndAllowThreads(__tstate);
25246 if (PyErr_Occurred()) SWIG_fail;
25247 }
25248 Py_INCREF(Py_None); resultobj = Py_None;
25249 return resultobj;
25250 fail:
25251 return NULL;
25252 }
25253
25254
25255 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25256 PyObject *resultobj;
25257 wxWindow *arg1 = (wxWindow *) 0 ;
25258 PyObject * obj0 = 0 ;
25259 char *kwnames[] = {
25260 (char *) "self", NULL
25261 };
25262
25263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25265 if (SWIG_arg_fail(1)) SWIG_fail;
25266 {
25267 PyThreadState* __tstate = wxPyBeginAllowThreads();
25268 (arg1)->Lower();
25269
25270 wxPyEndAllowThreads(__tstate);
25271 if (PyErr_Occurred()) SWIG_fail;
25272 }
25273 Py_INCREF(Py_None); resultobj = Py_None;
25274 return resultobj;
25275 fail:
25276 return NULL;
25277 }
25278
25279
25280 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25281 PyObject *resultobj;
25282 wxWindow *arg1 = (wxWindow *) 0 ;
25283 wxSize *arg2 = 0 ;
25284 wxSize temp2 ;
25285 PyObject * obj0 = 0 ;
25286 PyObject * obj1 = 0 ;
25287 char *kwnames[] = {
25288 (char *) "self",(char *) "size", NULL
25289 };
25290
25291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25293 if (SWIG_arg_fail(1)) SWIG_fail;
25294 {
25295 arg2 = &temp2;
25296 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25297 }
25298 {
25299 PyThreadState* __tstate = wxPyBeginAllowThreads();
25300 (arg1)->SetClientSize((wxSize const &)*arg2);
25301
25302 wxPyEndAllowThreads(__tstate);
25303 if (PyErr_Occurred()) SWIG_fail;
25304 }
25305 Py_INCREF(Py_None); resultobj = Py_None;
25306 return resultobj;
25307 fail:
25308 return NULL;
25309 }
25310
25311
25312 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25313 PyObject *resultobj;
25314 wxWindow *arg1 = (wxWindow *) 0 ;
25315 int arg2 ;
25316 int arg3 ;
25317 PyObject * obj0 = 0 ;
25318 PyObject * obj1 = 0 ;
25319 PyObject * obj2 = 0 ;
25320 char *kwnames[] = {
25321 (char *) "self",(char *) "width",(char *) "height", NULL
25322 };
25323
25324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25326 if (SWIG_arg_fail(1)) SWIG_fail;
25327 {
25328 arg2 = (int)(SWIG_As_int(obj1));
25329 if (SWIG_arg_fail(2)) SWIG_fail;
25330 }
25331 {
25332 arg3 = (int)(SWIG_As_int(obj2));
25333 if (SWIG_arg_fail(3)) SWIG_fail;
25334 }
25335 {
25336 PyThreadState* __tstate = wxPyBeginAllowThreads();
25337 (arg1)->SetClientSize(arg2,arg3);
25338
25339 wxPyEndAllowThreads(__tstate);
25340 if (PyErr_Occurred()) SWIG_fail;
25341 }
25342 Py_INCREF(Py_None); resultobj = Py_None;
25343 return resultobj;
25344 fail:
25345 return NULL;
25346 }
25347
25348
25349 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25350 PyObject *resultobj;
25351 wxWindow *arg1 = (wxWindow *) 0 ;
25352 wxRect *arg2 = 0 ;
25353 wxRect temp2 ;
25354 PyObject * obj0 = 0 ;
25355 PyObject * obj1 = 0 ;
25356 char *kwnames[] = {
25357 (char *) "self",(char *) "rect", NULL
25358 };
25359
25360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25362 if (SWIG_arg_fail(1)) SWIG_fail;
25363 {
25364 arg2 = &temp2;
25365 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25366 }
25367 {
25368 PyThreadState* __tstate = wxPyBeginAllowThreads();
25369 (arg1)->SetClientSize((wxRect const &)*arg2);
25370
25371 wxPyEndAllowThreads(__tstate);
25372 if (PyErr_Occurred()) SWIG_fail;
25373 }
25374 Py_INCREF(Py_None); resultobj = Py_None;
25375 return resultobj;
25376 fail:
25377 return NULL;
25378 }
25379
25380
25381 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25382 PyObject *resultobj;
25383 wxWindow *arg1 = (wxWindow *) 0 ;
25384 wxPoint result;
25385 PyObject * obj0 = 0 ;
25386 char *kwnames[] = {
25387 (char *) "self", NULL
25388 };
25389
25390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
25391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25392 if (SWIG_arg_fail(1)) SWIG_fail;
25393 {
25394 PyThreadState* __tstate = wxPyBeginAllowThreads();
25395 result = (arg1)->GetPosition();
25396
25397 wxPyEndAllowThreads(__tstate);
25398 if (PyErr_Occurred()) SWIG_fail;
25399 }
25400 {
25401 wxPoint * resultptr;
25402 resultptr = new wxPoint((wxPoint &)(result));
25403 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25404 }
25405 return resultobj;
25406 fail:
25407 return NULL;
25408 }
25409
25410
25411 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25412 PyObject *resultobj;
25413 wxWindow *arg1 = (wxWindow *) 0 ;
25414 int *arg2 = (int *) 0 ;
25415 int *arg3 = (int *) 0 ;
25416 int temp2 ;
25417 int res2 = 0 ;
25418 int temp3 ;
25419 int res3 = 0 ;
25420 PyObject * obj0 = 0 ;
25421 char *kwnames[] = {
25422 (char *) "self", NULL
25423 };
25424
25425 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25426 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25429 if (SWIG_arg_fail(1)) SWIG_fail;
25430 {
25431 PyThreadState* __tstate = wxPyBeginAllowThreads();
25432 (arg1)->GetPosition(arg2,arg3);
25433
25434 wxPyEndAllowThreads(__tstate);
25435 if (PyErr_Occurred()) SWIG_fail;
25436 }
25437 Py_INCREF(Py_None); resultobj = Py_None;
25438 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25439 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25440 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25441 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25442 return resultobj;
25443 fail:
25444 return NULL;
25445 }
25446
25447
25448 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25449 PyObject *resultobj;
25450 wxWindow *arg1 = (wxWindow *) 0 ;
25451 wxSize result;
25452 PyObject * obj0 = 0 ;
25453 char *kwnames[] = {
25454 (char *) "self", NULL
25455 };
25456
25457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
25458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25459 if (SWIG_arg_fail(1)) SWIG_fail;
25460 {
25461 PyThreadState* __tstate = wxPyBeginAllowThreads();
25462 result = ((wxWindow const *)arg1)->GetSize();
25463
25464 wxPyEndAllowThreads(__tstate);
25465 if (PyErr_Occurred()) SWIG_fail;
25466 }
25467 {
25468 wxSize * resultptr;
25469 resultptr = new wxSize((wxSize &)(result));
25470 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25471 }
25472 return resultobj;
25473 fail:
25474 return NULL;
25475 }
25476
25477
25478 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25479 PyObject *resultobj;
25480 wxWindow *arg1 = (wxWindow *) 0 ;
25481 int *arg2 = (int *) 0 ;
25482 int *arg3 = (int *) 0 ;
25483 int temp2 ;
25484 int res2 = 0 ;
25485 int temp3 ;
25486 int res3 = 0 ;
25487 PyObject * obj0 = 0 ;
25488 char *kwnames[] = {
25489 (char *) "self", NULL
25490 };
25491
25492 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25493 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
25495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25496 if (SWIG_arg_fail(1)) SWIG_fail;
25497 {
25498 PyThreadState* __tstate = wxPyBeginAllowThreads();
25499 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
25500
25501 wxPyEndAllowThreads(__tstate);
25502 if (PyErr_Occurred()) SWIG_fail;
25503 }
25504 Py_INCREF(Py_None); resultobj = Py_None;
25505 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25506 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25507 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25508 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25509 return resultobj;
25510 fail:
25511 return NULL;
25512 }
25513
25514
25515 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25516 PyObject *resultobj;
25517 wxWindow *arg1 = (wxWindow *) 0 ;
25518 wxRect result;
25519 PyObject * obj0 = 0 ;
25520 char *kwnames[] = {
25521 (char *) "self", NULL
25522 };
25523
25524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
25525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25526 if (SWIG_arg_fail(1)) SWIG_fail;
25527 {
25528 PyThreadState* __tstate = wxPyBeginAllowThreads();
25529 result = ((wxWindow const *)arg1)->GetRect();
25530
25531 wxPyEndAllowThreads(__tstate);
25532 if (PyErr_Occurred()) SWIG_fail;
25533 }
25534 {
25535 wxRect * resultptr;
25536 resultptr = new wxRect((wxRect &)(result));
25537 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25538 }
25539 return resultobj;
25540 fail:
25541 return NULL;
25542 }
25543
25544
25545 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25546 PyObject *resultobj;
25547 wxWindow *arg1 = (wxWindow *) 0 ;
25548 wxSize result;
25549 PyObject * obj0 = 0 ;
25550 char *kwnames[] = {
25551 (char *) "self", NULL
25552 };
25553
25554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
25555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25556 if (SWIG_arg_fail(1)) SWIG_fail;
25557 {
25558 PyThreadState* __tstate = wxPyBeginAllowThreads();
25559 result = ((wxWindow const *)arg1)->GetClientSize();
25560
25561 wxPyEndAllowThreads(__tstate);
25562 if (PyErr_Occurred()) SWIG_fail;
25563 }
25564 {
25565 wxSize * resultptr;
25566 resultptr = new wxSize((wxSize &)(result));
25567 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25568 }
25569 return resultobj;
25570 fail:
25571 return NULL;
25572 }
25573
25574
25575 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25576 PyObject *resultobj;
25577 wxWindow *arg1 = (wxWindow *) 0 ;
25578 int *arg2 = (int *) 0 ;
25579 int *arg3 = (int *) 0 ;
25580 int temp2 ;
25581 int res2 = 0 ;
25582 int temp3 ;
25583 int res3 = 0 ;
25584 PyObject * obj0 = 0 ;
25585 char *kwnames[] = {
25586 (char *) "self", NULL
25587 };
25588
25589 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25590 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
25592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25593 if (SWIG_arg_fail(1)) SWIG_fail;
25594 {
25595 PyThreadState* __tstate = wxPyBeginAllowThreads();
25596 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
25597
25598 wxPyEndAllowThreads(__tstate);
25599 if (PyErr_Occurred()) SWIG_fail;
25600 }
25601 Py_INCREF(Py_None); resultobj = Py_None;
25602 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25603 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25604 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25605 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25606 return resultobj;
25607 fail:
25608 return NULL;
25609 }
25610
25611
25612 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
25613 PyObject *resultobj;
25614 wxWindow *arg1 = (wxWindow *) 0 ;
25615 wxPoint result;
25616 PyObject * obj0 = 0 ;
25617 char *kwnames[] = {
25618 (char *) "self", NULL
25619 };
25620
25621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
25622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25623 if (SWIG_arg_fail(1)) SWIG_fail;
25624 {
25625 PyThreadState* __tstate = wxPyBeginAllowThreads();
25626 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
25627
25628 wxPyEndAllowThreads(__tstate);
25629 if (PyErr_Occurred()) SWIG_fail;
25630 }
25631 {
25632 wxPoint * resultptr;
25633 resultptr = new wxPoint((wxPoint &)(result));
25634 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25635 }
25636 return resultobj;
25637 fail:
25638 return NULL;
25639 }
25640
25641
25642 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25643 PyObject *resultobj;
25644 wxWindow *arg1 = (wxWindow *) 0 ;
25645 wxRect result;
25646 PyObject * obj0 = 0 ;
25647 char *kwnames[] = {
25648 (char *) "self", NULL
25649 };
25650
25651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
25652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25653 if (SWIG_arg_fail(1)) SWIG_fail;
25654 {
25655 PyThreadState* __tstate = wxPyBeginAllowThreads();
25656 result = ((wxWindow const *)arg1)->GetClientRect();
25657
25658 wxPyEndAllowThreads(__tstate);
25659 if (PyErr_Occurred()) SWIG_fail;
25660 }
25661 {
25662 wxRect * resultptr;
25663 resultptr = new wxRect((wxRect &)(result));
25664 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25665 }
25666 return resultobj;
25667 fail:
25668 return NULL;
25669 }
25670
25671
25672 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25673 PyObject *resultobj;
25674 wxWindow *arg1 = (wxWindow *) 0 ;
25675 wxSize result;
25676 PyObject * obj0 = 0 ;
25677 char *kwnames[] = {
25678 (char *) "self", NULL
25679 };
25680
25681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
25682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25683 if (SWIG_arg_fail(1)) SWIG_fail;
25684 {
25685 PyThreadState* __tstate = wxPyBeginAllowThreads();
25686 result = ((wxWindow const *)arg1)->GetBestSize();
25687
25688 wxPyEndAllowThreads(__tstate);
25689 if (PyErr_Occurred()) SWIG_fail;
25690 }
25691 {
25692 wxSize * resultptr;
25693 resultptr = new wxSize((wxSize &)(result));
25694 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25695 }
25696 return resultobj;
25697 fail:
25698 return NULL;
25699 }
25700
25701
25702 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25703 PyObject *resultobj;
25704 wxWindow *arg1 = (wxWindow *) 0 ;
25705 int *arg2 = (int *) 0 ;
25706 int *arg3 = (int *) 0 ;
25707 int temp2 ;
25708 int res2 = 0 ;
25709 int temp3 ;
25710 int res3 = 0 ;
25711 PyObject * obj0 = 0 ;
25712 char *kwnames[] = {
25713 (char *) "self", NULL
25714 };
25715
25716 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25717 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
25719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25720 if (SWIG_arg_fail(1)) SWIG_fail;
25721 {
25722 PyThreadState* __tstate = wxPyBeginAllowThreads();
25723 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
25724
25725 wxPyEndAllowThreads(__tstate);
25726 if (PyErr_Occurred()) SWIG_fail;
25727 }
25728 Py_INCREF(Py_None); resultobj = Py_None;
25729 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25730 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25731 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25732 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25733 return resultobj;
25734 fail:
25735 return NULL;
25736 }
25737
25738
25739 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25740 PyObject *resultobj;
25741 wxWindow *arg1 = (wxWindow *) 0 ;
25742 PyObject * obj0 = 0 ;
25743 char *kwnames[] = {
25744 (char *) "self", NULL
25745 };
25746
25747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
25748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25749 if (SWIG_arg_fail(1)) SWIG_fail;
25750 {
25751 PyThreadState* __tstate = wxPyBeginAllowThreads();
25752 (arg1)->InvalidateBestSize();
25753
25754 wxPyEndAllowThreads(__tstate);
25755 if (PyErr_Occurred()) SWIG_fail;
25756 }
25757 Py_INCREF(Py_None); resultobj = Py_None;
25758 return resultobj;
25759 fail:
25760 return NULL;
25761 }
25762
25763
25764 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25765 PyObject *resultobj;
25766 wxWindow *arg1 = (wxWindow *) 0 ;
25767 wxSize result;
25768 PyObject * obj0 = 0 ;
25769 char *kwnames[] = {
25770 (char *) "self", NULL
25771 };
25772
25773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
25774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25775 if (SWIG_arg_fail(1)) SWIG_fail;
25776 {
25777 PyThreadState* __tstate = wxPyBeginAllowThreads();
25778 result = ((wxWindow const *)arg1)->GetBestFittingSize();
25779
25780 wxPyEndAllowThreads(__tstate);
25781 if (PyErr_Occurred()) SWIG_fail;
25782 }
25783 {
25784 wxSize * resultptr;
25785 resultptr = new wxSize((wxSize &)(result));
25786 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25787 }
25788 return resultobj;
25789 fail:
25790 return NULL;
25791 }
25792
25793
25794 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25795 PyObject *resultobj;
25796 wxWindow *arg1 = (wxWindow *) 0 ;
25797 wxSize result;
25798 PyObject * obj0 = 0 ;
25799 char *kwnames[] = {
25800 (char *) "self", NULL
25801 };
25802
25803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
25804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25805 if (SWIG_arg_fail(1)) SWIG_fail;
25806 {
25807 PyThreadState* __tstate = wxPyBeginAllowThreads();
25808 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
25809
25810 wxPyEndAllowThreads(__tstate);
25811 if (PyErr_Occurred()) SWIG_fail;
25812 }
25813 {
25814 wxSize * resultptr;
25815 resultptr = new wxSize((wxSize &)(result));
25816 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25817 }
25818 return resultobj;
25819 fail:
25820 return NULL;
25821 }
25822
25823
25824 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
25825 PyObject *resultobj;
25826 wxWindow *arg1 = (wxWindow *) 0 ;
25827 int arg2 = (int) wxBOTH ;
25828 PyObject * obj0 = 0 ;
25829 PyObject * obj1 = 0 ;
25830 char *kwnames[] = {
25831 (char *) "self",(char *) "direction", NULL
25832 };
25833
25834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
25835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25836 if (SWIG_arg_fail(1)) SWIG_fail;
25837 if (obj1) {
25838 {
25839 arg2 = (int)(SWIG_As_int(obj1));
25840 if (SWIG_arg_fail(2)) SWIG_fail;
25841 }
25842 }
25843 {
25844 PyThreadState* __tstate = wxPyBeginAllowThreads();
25845 (arg1)->Center(arg2);
25846
25847 wxPyEndAllowThreads(__tstate);
25848 if (PyErr_Occurred()) SWIG_fail;
25849 }
25850 Py_INCREF(Py_None); resultobj = Py_None;
25851 return resultobj;
25852 fail:
25853 return NULL;
25854 }
25855
25856
25857 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
25858 PyObject *resultobj;
25859 wxWindow *arg1 = (wxWindow *) 0 ;
25860 int arg2 = (int) wxBOTH ;
25861 PyObject * obj0 = 0 ;
25862 PyObject * obj1 = 0 ;
25863 char *kwnames[] = {
25864 (char *) "self",(char *) "dir", NULL
25865 };
25866
25867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
25868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25869 if (SWIG_arg_fail(1)) SWIG_fail;
25870 if (obj1) {
25871 {
25872 arg2 = (int)(SWIG_As_int(obj1));
25873 if (SWIG_arg_fail(2)) SWIG_fail;
25874 }
25875 }
25876 {
25877 PyThreadState* __tstate = wxPyBeginAllowThreads();
25878 (arg1)->CenterOnScreen(arg2);
25879
25880 wxPyEndAllowThreads(__tstate);
25881 if (PyErr_Occurred()) SWIG_fail;
25882 }
25883 Py_INCREF(Py_None); resultobj = Py_None;
25884 return resultobj;
25885 fail:
25886 return NULL;
25887 }
25888
25889
25890 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
25891 PyObject *resultobj;
25892 wxWindow *arg1 = (wxWindow *) 0 ;
25893 int arg2 = (int) wxBOTH ;
25894 PyObject * obj0 = 0 ;
25895 PyObject * obj1 = 0 ;
25896 char *kwnames[] = {
25897 (char *) "self",(char *) "dir", NULL
25898 };
25899
25900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
25901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25902 if (SWIG_arg_fail(1)) SWIG_fail;
25903 if (obj1) {
25904 {
25905 arg2 = (int)(SWIG_As_int(obj1));
25906 if (SWIG_arg_fail(2)) SWIG_fail;
25907 }
25908 }
25909 {
25910 PyThreadState* __tstate = wxPyBeginAllowThreads();
25911 (arg1)->CenterOnParent(arg2);
25912
25913 wxPyEndAllowThreads(__tstate);
25914 if (PyErr_Occurred()) SWIG_fail;
25915 }
25916 Py_INCREF(Py_None); resultobj = Py_None;
25917 return resultobj;
25918 fail:
25919 return NULL;
25920 }
25921
25922
25923 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
25924 PyObject *resultobj;
25925 wxWindow *arg1 = (wxWindow *) 0 ;
25926 PyObject * obj0 = 0 ;
25927 char *kwnames[] = {
25928 (char *) "self", NULL
25929 };
25930
25931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
25932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25933 if (SWIG_arg_fail(1)) SWIG_fail;
25934 {
25935 PyThreadState* __tstate = wxPyBeginAllowThreads();
25936 (arg1)->Fit();
25937
25938 wxPyEndAllowThreads(__tstate);
25939 if (PyErr_Occurred()) SWIG_fail;
25940 }
25941 Py_INCREF(Py_None); resultobj = Py_None;
25942 return resultobj;
25943 fail:
25944 return NULL;
25945 }
25946
25947
25948 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
25949 PyObject *resultobj;
25950 wxWindow *arg1 = (wxWindow *) 0 ;
25951 PyObject * obj0 = 0 ;
25952 char *kwnames[] = {
25953 (char *) "self", NULL
25954 };
25955
25956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
25957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25958 if (SWIG_arg_fail(1)) SWIG_fail;
25959 {
25960 PyThreadState* __tstate = wxPyBeginAllowThreads();
25961 (arg1)->FitInside();
25962
25963 wxPyEndAllowThreads(__tstate);
25964 if (PyErr_Occurred()) SWIG_fail;
25965 }
25966 Py_INCREF(Py_None); resultobj = Py_None;
25967 return resultobj;
25968 fail:
25969 return NULL;
25970 }
25971
25972
25973 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
25974 PyObject *resultobj;
25975 wxWindow *arg1 = (wxWindow *) 0 ;
25976 int arg2 ;
25977 int arg3 ;
25978 int arg4 = (int) -1 ;
25979 int arg5 = (int) -1 ;
25980 int arg6 = (int) -1 ;
25981 int arg7 = (int) -1 ;
25982 PyObject * obj0 = 0 ;
25983 PyObject * obj1 = 0 ;
25984 PyObject * obj2 = 0 ;
25985 PyObject * obj3 = 0 ;
25986 PyObject * obj4 = 0 ;
25987 PyObject * obj5 = 0 ;
25988 PyObject * obj6 = 0 ;
25989 char *kwnames[] = {
25990 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
25991 };
25992
25993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25995 if (SWIG_arg_fail(1)) SWIG_fail;
25996 {
25997 arg2 = (int)(SWIG_As_int(obj1));
25998 if (SWIG_arg_fail(2)) SWIG_fail;
25999 }
26000 {
26001 arg3 = (int)(SWIG_As_int(obj2));
26002 if (SWIG_arg_fail(3)) SWIG_fail;
26003 }
26004 if (obj3) {
26005 {
26006 arg4 = (int)(SWIG_As_int(obj3));
26007 if (SWIG_arg_fail(4)) SWIG_fail;
26008 }
26009 }
26010 if (obj4) {
26011 {
26012 arg5 = (int)(SWIG_As_int(obj4));
26013 if (SWIG_arg_fail(5)) SWIG_fail;
26014 }
26015 }
26016 if (obj5) {
26017 {
26018 arg6 = (int)(SWIG_As_int(obj5));
26019 if (SWIG_arg_fail(6)) SWIG_fail;
26020 }
26021 }
26022 if (obj6) {
26023 {
26024 arg7 = (int)(SWIG_As_int(obj6));
26025 if (SWIG_arg_fail(7)) SWIG_fail;
26026 }
26027 }
26028 {
26029 PyThreadState* __tstate = wxPyBeginAllowThreads();
26030 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26031
26032 wxPyEndAllowThreads(__tstate);
26033 if (PyErr_Occurred()) SWIG_fail;
26034 }
26035 Py_INCREF(Py_None); resultobj = Py_None;
26036 return resultobj;
26037 fail:
26038 return NULL;
26039 }
26040
26041
26042 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26043 PyObject *resultobj;
26044 wxWindow *arg1 = (wxWindow *) 0 ;
26045 wxSize *arg2 = 0 ;
26046 wxSize const &arg3_defvalue = wxDefaultSize ;
26047 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26048 wxSize const &arg4_defvalue = wxDefaultSize ;
26049 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26050 wxSize temp2 ;
26051 wxSize temp3 ;
26052 wxSize temp4 ;
26053 PyObject * obj0 = 0 ;
26054 PyObject * obj1 = 0 ;
26055 PyObject * obj2 = 0 ;
26056 PyObject * obj3 = 0 ;
26057 char *kwnames[] = {
26058 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26059 };
26060
26061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26063 if (SWIG_arg_fail(1)) SWIG_fail;
26064 {
26065 arg2 = &temp2;
26066 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26067 }
26068 if (obj2) {
26069 {
26070 arg3 = &temp3;
26071 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26072 }
26073 }
26074 if (obj3) {
26075 {
26076 arg4 = &temp4;
26077 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26078 }
26079 }
26080 {
26081 PyThreadState* __tstate = wxPyBeginAllowThreads();
26082 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26083
26084 wxPyEndAllowThreads(__tstate);
26085 if (PyErr_Occurred()) SWIG_fail;
26086 }
26087 Py_INCREF(Py_None); resultobj = Py_None;
26088 return resultobj;
26089 fail:
26090 return NULL;
26091 }
26092
26093
26094 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26095 PyObject *resultobj;
26096 wxWindow *arg1 = (wxWindow *) 0 ;
26097 int arg2 ;
26098 int arg3 ;
26099 int arg4 = (int) -1 ;
26100 int arg5 = (int) -1 ;
26101 PyObject * obj0 = 0 ;
26102 PyObject * obj1 = 0 ;
26103 PyObject * obj2 = 0 ;
26104 PyObject * obj3 = 0 ;
26105 PyObject * obj4 = 0 ;
26106 char *kwnames[] = {
26107 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26108 };
26109
26110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26112 if (SWIG_arg_fail(1)) SWIG_fail;
26113 {
26114 arg2 = (int)(SWIG_As_int(obj1));
26115 if (SWIG_arg_fail(2)) SWIG_fail;
26116 }
26117 {
26118 arg3 = (int)(SWIG_As_int(obj2));
26119 if (SWIG_arg_fail(3)) SWIG_fail;
26120 }
26121 if (obj3) {
26122 {
26123 arg4 = (int)(SWIG_As_int(obj3));
26124 if (SWIG_arg_fail(4)) SWIG_fail;
26125 }
26126 }
26127 if (obj4) {
26128 {
26129 arg5 = (int)(SWIG_As_int(obj4));
26130 if (SWIG_arg_fail(5)) SWIG_fail;
26131 }
26132 }
26133 {
26134 PyThreadState* __tstate = wxPyBeginAllowThreads();
26135 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26136
26137 wxPyEndAllowThreads(__tstate);
26138 if (PyErr_Occurred()) SWIG_fail;
26139 }
26140 Py_INCREF(Py_None); resultobj = Py_None;
26141 return resultobj;
26142 fail:
26143 return NULL;
26144 }
26145
26146
26147 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26148 PyObject *resultobj;
26149 wxWindow *arg1 = (wxWindow *) 0 ;
26150 wxSize *arg2 = 0 ;
26151 wxSize const &arg3_defvalue = wxDefaultSize ;
26152 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26153 wxSize temp2 ;
26154 wxSize temp3 ;
26155 PyObject * obj0 = 0 ;
26156 PyObject * obj1 = 0 ;
26157 PyObject * obj2 = 0 ;
26158 char *kwnames[] = {
26159 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26160 };
26161
26162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26164 if (SWIG_arg_fail(1)) SWIG_fail;
26165 {
26166 arg2 = &temp2;
26167 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26168 }
26169 if (obj2) {
26170 {
26171 arg3 = &temp3;
26172 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26173 }
26174 }
26175 {
26176 PyThreadState* __tstate = wxPyBeginAllowThreads();
26177 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26178
26179 wxPyEndAllowThreads(__tstate);
26180 if (PyErr_Occurred()) SWIG_fail;
26181 }
26182 Py_INCREF(Py_None); resultobj = Py_None;
26183 return resultobj;
26184 fail:
26185 return NULL;
26186 }
26187
26188
26189 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26190 PyObject *resultobj;
26191 wxWindow *arg1 = (wxWindow *) 0 ;
26192 wxSize result;
26193 PyObject * obj0 = 0 ;
26194 char *kwnames[] = {
26195 (char *) "self", NULL
26196 };
26197
26198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26200 if (SWIG_arg_fail(1)) SWIG_fail;
26201 {
26202 PyThreadState* __tstate = wxPyBeginAllowThreads();
26203 result = ((wxWindow const *)arg1)->GetMaxSize();
26204
26205 wxPyEndAllowThreads(__tstate);
26206 if (PyErr_Occurred()) SWIG_fail;
26207 }
26208 {
26209 wxSize * resultptr;
26210 resultptr = new wxSize((wxSize &)(result));
26211 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26212 }
26213 return resultobj;
26214 fail:
26215 return NULL;
26216 }
26217
26218
26219 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26220 PyObject *resultobj;
26221 wxWindow *arg1 = (wxWindow *) 0 ;
26222 wxSize result;
26223 PyObject * obj0 = 0 ;
26224 char *kwnames[] = {
26225 (char *) "self", NULL
26226 };
26227
26228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26230 if (SWIG_arg_fail(1)) SWIG_fail;
26231 {
26232 PyThreadState* __tstate = wxPyBeginAllowThreads();
26233 result = ((wxWindow const *)arg1)->GetMinSize();
26234
26235 wxPyEndAllowThreads(__tstate);
26236 if (PyErr_Occurred()) SWIG_fail;
26237 }
26238 {
26239 wxSize * resultptr;
26240 resultptr = new wxSize((wxSize &)(result));
26241 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26242 }
26243 return resultobj;
26244 fail:
26245 return NULL;
26246 }
26247
26248
26249 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26250 PyObject *resultobj;
26251 wxWindow *arg1 = (wxWindow *) 0 ;
26252 wxSize *arg2 = 0 ;
26253 wxSize temp2 ;
26254 PyObject * obj0 = 0 ;
26255 PyObject * obj1 = 0 ;
26256 char *kwnames[] = {
26257 (char *) "self",(char *) "minSize", NULL
26258 };
26259
26260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26262 if (SWIG_arg_fail(1)) SWIG_fail;
26263 {
26264 arg2 = &temp2;
26265 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26266 }
26267 {
26268 PyThreadState* __tstate = wxPyBeginAllowThreads();
26269 (arg1)->SetMinSize((wxSize const &)*arg2);
26270
26271 wxPyEndAllowThreads(__tstate);
26272 if (PyErr_Occurred()) SWIG_fail;
26273 }
26274 Py_INCREF(Py_None); resultobj = Py_None;
26275 return resultobj;
26276 fail:
26277 return NULL;
26278 }
26279
26280
26281 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26282 PyObject *resultobj;
26283 wxWindow *arg1 = (wxWindow *) 0 ;
26284 wxSize *arg2 = 0 ;
26285 wxSize temp2 ;
26286 PyObject * obj0 = 0 ;
26287 PyObject * obj1 = 0 ;
26288 char *kwnames[] = {
26289 (char *) "self",(char *) "maxSize", NULL
26290 };
26291
26292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26294 if (SWIG_arg_fail(1)) SWIG_fail;
26295 {
26296 arg2 = &temp2;
26297 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26298 }
26299 {
26300 PyThreadState* __tstate = wxPyBeginAllowThreads();
26301 (arg1)->SetMaxSize((wxSize const &)*arg2);
26302
26303 wxPyEndAllowThreads(__tstate);
26304 if (PyErr_Occurred()) SWIG_fail;
26305 }
26306 Py_INCREF(Py_None); resultobj = Py_None;
26307 return resultobj;
26308 fail:
26309 return NULL;
26310 }
26311
26312
26313 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26314 PyObject *resultobj;
26315 wxWindow *arg1 = (wxWindow *) 0 ;
26316 int result;
26317 PyObject * obj0 = 0 ;
26318 char *kwnames[] = {
26319 (char *) "self", NULL
26320 };
26321
26322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
26323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26324 if (SWIG_arg_fail(1)) SWIG_fail;
26325 {
26326 PyThreadState* __tstate = wxPyBeginAllowThreads();
26327 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26328
26329 wxPyEndAllowThreads(__tstate);
26330 if (PyErr_Occurred()) SWIG_fail;
26331 }
26332 {
26333 resultobj = SWIG_From_int((int)(result));
26334 }
26335 return resultobj;
26336 fail:
26337 return NULL;
26338 }
26339
26340
26341 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26342 PyObject *resultobj;
26343 wxWindow *arg1 = (wxWindow *) 0 ;
26344 int result;
26345 PyObject * obj0 = 0 ;
26346 char *kwnames[] = {
26347 (char *) "self", NULL
26348 };
26349
26350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26352 if (SWIG_arg_fail(1)) SWIG_fail;
26353 {
26354 PyThreadState* __tstate = wxPyBeginAllowThreads();
26355 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26356
26357 wxPyEndAllowThreads(__tstate);
26358 if (PyErr_Occurred()) SWIG_fail;
26359 }
26360 {
26361 resultobj = SWIG_From_int((int)(result));
26362 }
26363 return resultobj;
26364 fail:
26365 return NULL;
26366 }
26367
26368
26369 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26370 PyObject *resultobj;
26371 wxWindow *arg1 = (wxWindow *) 0 ;
26372 int result;
26373 PyObject * obj0 = 0 ;
26374 char *kwnames[] = {
26375 (char *) "self", NULL
26376 };
26377
26378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26380 if (SWIG_arg_fail(1)) SWIG_fail;
26381 {
26382 PyThreadState* __tstate = wxPyBeginAllowThreads();
26383 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26384
26385 wxPyEndAllowThreads(__tstate);
26386 if (PyErr_Occurred()) SWIG_fail;
26387 }
26388 {
26389 resultobj = SWIG_From_int((int)(result));
26390 }
26391 return resultobj;
26392 fail:
26393 return NULL;
26394 }
26395
26396
26397 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26398 PyObject *resultobj;
26399 wxWindow *arg1 = (wxWindow *) 0 ;
26400 int result;
26401 PyObject * obj0 = 0 ;
26402 char *kwnames[] = {
26403 (char *) "self", NULL
26404 };
26405
26406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26408 if (SWIG_arg_fail(1)) SWIG_fail;
26409 {
26410 PyThreadState* __tstate = wxPyBeginAllowThreads();
26411 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26412
26413 wxPyEndAllowThreads(__tstate);
26414 if (PyErr_Occurred()) SWIG_fail;
26415 }
26416 {
26417 resultobj = SWIG_From_int((int)(result));
26418 }
26419 return resultobj;
26420 fail:
26421 return NULL;
26422 }
26423
26424
26425 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26426 PyObject *resultobj;
26427 wxWindow *arg1 = (wxWindow *) 0 ;
26428 wxSize *arg2 = 0 ;
26429 wxSize temp2 ;
26430 PyObject * obj0 = 0 ;
26431 PyObject * obj1 = 0 ;
26432 char *kwnames[] = {
26433 (char *) "self",(char *) "size", NULL
26434 };
26435
26436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26438 if (SWIG_arg_fail(1)) SWIG_fail;
26439 {
26440 arg2 = &temp2;
26441 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26442 }
26443 {
26444 PyThreadState* __tstate = wxPyBeginAllowThreads();
26445 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26446
26447 wxPyEndAllowThreads(__tstate);
26448 if (PyErr_Occurred()) SWIG_fail;
26449 }
26450 Py_INCREF(Py_None); resultobj = Py_None;
26451 return resultobj;
26452 fail:
26453 return NULL;
26454 }
26455
26456
26457 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26458 PyObject *resultobj;
26459 wxWindow *arg1 = (wxWindow *) 0 ;
26460 int arg2 ;
26461 int arg3 ;
26462 PyObject * obj0 = 0 ;
26463 PyObject * obj1 = 0 ;
26464 PyObject * obj2 = 0 ;
26465 char *kwnames[] = {
26466 (char *) "self",(char *) "w",(char *) "h", NULL
26467 };
26468
26469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26471 if (SWIG_arg_fail(1)) SWIG_fail;
26472 {
26473 arg2 = (int)(SWIG_As_int(obj1));
26474 if (SWIG_arg_fail(2)) SWIG_fail;
26475 }
26476 {
26477 arg3 = (int)(SWIG_As_int(obj2));
26478 if (SWIG_arg_fail(3)) SWIG_fail;
26479 }
26480 {
26481 PyThreadState* __tstate = wxPyBeginAllowThreads();
26482 (arg1)->SetVirtualSize(arg2,arg3);
26483
26484 wxPyEndAllowThreads(__tstate);
26485 if (PyErr_Occurred()) SWIG_fail;
26486 }
26487 Py_INCREF(Py_None); resultobj = Py_None;
26488 return resultobj;
26489 fail:
26490 return NULL;
26491 }
26492
26493
26494 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26495 PyObject *resultobj;
26496 wxWindow *arg1 = (wxWindow *) 0 ;
26497 wxSize result;
26498 PyObject * obj0 = 0 ;
26499 char *kwnames[] = {
26500 (char *) "self", NULL
26501 };
26502
26503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
26504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26505 if (SWIG_arg_fail(1)) SWIG_fail;
26506 {
26507 PyThreadState* __tstate = wxPyBeginAllowThreads();
26508 result = ((wxWindow const *)arg1)->GetVirtualSize();
26509
26510 wxPyEndAllowThreads(__tstate);
26511 if (PyErr_Occurred()) SWIG_fail;
26512 }
26513 {
26514 wxSize * resultptr;
26515 resultptr = new wxSize((wxSize &)(result));
26516 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26517 }
26518 return resultobj;
26519 fail:
26520 return NULL;
26521 }
26522
26523
26524 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26525 PyObject *resultobj;
26526 wxWindow *arg1 = (wxWindow *) 0 ;
26527 int *arg2 = (int *) 0 ;
26528 int *arg3 = (int *) 0 ;
26529 int temp2 ;
26530 int res2 = 0 ;
26531 int temp3 ;
26532 int res3 = 0 ;
26533 PyObject * obj0 = 0 ;
26534 char *kwnames[] = {
26535 (char *) "self", NULL
26536 };
26537
26538 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26539 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
26541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26542 if (SWIG_arg_fail(1)) SWIG_fail;
26543 {
26544 PyThreadState* __tstate = wxPyBeginAllowThreads();
26545 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
26546
26547 wxPyEndAllowThreads(__tstate);
26548 if (PyErr_Occurred()) SWIG_fail;
26549 }
26550 Py_INCREF(Py_None); resultobj = Py_None;
26551 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26552 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26553 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26554 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26555 return resultobj;
26556 fail:
26557 return NULL;
26558 }
26559
26560
26561 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26562 PyObject *resultobj;
26563 wxWindow *arg1 = (wxWindow *) 0 ;
26564 wxSize result;
26565 PyObject * obj0 = 0 ;
26566 char *kwnames[] = {
26567 (char *) "self", NULL
26568 };
26569
26570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
26571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26572 if (SWIG_arg_fail(1)) SWIG_fail;
26573 {
26574 PyThreadState* __tstate = wxPyBeginAllowThreads();
26575 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
26576
26577 wxPyEndAllowThreads(__tstate);
26578 if (PyErr_Occurred()) SWIG_fail;
26579 }
26580 {
26581 wxSize * resultptr;
26582 resultptr = new wxSize((wxSize &)(result));
26583 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26584 }
26585 return resultobj;
26586 fail:
26587 return NULL;
26588 }
26589
26590
26591 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
26592 PyObject *resultobj;
26593 wxWindow *arg1 = (wxWindow *) 0 ;
26594 bool arg2 = (bool) true ;
26595 bool result;
26596 PyObject * obj0 = 0 ;
26597 PyObject * obj1 = 0 ;
26598 char *kwnames[] = {
26599 (char *) "self",(char *) "show", NULL
26600 };
26601
26602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
26603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26604 if (SWIG_arg_fail(1)) SWIG_fail;
26605 if (obj1) {
26606 {
26607 arg2 = (bool)(SWIG_As_bool(obj1));
26608 if (SWIG_arg_fail(2)) SWIG_fail;
26609 }
26610 }
26611 {
26612 PyThreadState* __tstate = wxPyBeginAllowThreads();
26613 result = (bool)(arg1)->Show(arg2);
26614
26615 wxPyEndAllowThreads(__tstate);
26616 if (PyErr_Occurred()) SWIG_fail;
26617 }
26618 {
26619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26620 }
26621 return resultobj;
26622 fail:
26623 return NULL;
26624 }
26625
26626
26627 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
26628 PyObject *resultobj;
26629 wxWindow *arg1 = (wxWindow *) 0 ;
26630 bool result;
26631 PyObject * obj0 = 0 ;
26632 char *kwnames[] = {
26633 (char *) "self", NULL
26634 };
26635
26636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
26637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26638 if (SWIG_arg_fail(1)) SWIG_fail;
26639 {
26640 PyThreadState* __tstate = wxPyBeginAllowThreads();
26641 result = (bool)(arg1)->Hide();
26642
26643 wxPyEndAllowThreads(__tstate);
26644 if (PyErr_Occurred()) SWIG_fail;
26645 }
26646 {
26647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26648 }
26649 return resultobj;
26650 fail:
26651 return NULL;
26652 }
26653
26654
26655 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
26656 PyObject *resultobj;
26657 wxWindow *arg1 = (wxWindow *) 0 ;
26658 bool arg2 = (bool) true ;
26659 bool result;
26660 PyObject * obj0 = 0 ;
26661 PyObject * obj1 = 0 ;
26662 char *kwnames[] = {
26663 (char *) "self",(char *) "enable", NULL
26664 };
26665
26666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
26667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26668 if (SWIG_arg_fail(1)) SWIG_fail;
26669 if (obj1) {
26670 {
26671 arg2 = (bool)(SWIG_As_bool(obj1));
26672 if (SWIG_arg_fail(2)) SWIG_fail;
26673 }
26674 }
26675 {
26676 PyThreadState* __tstate = wxPyBeginAllowThreads();
26677 result = (bool)(arg1)->Enable(arg2);
26678
26679 wxPyEndAllowThreads(__tstate);
26680 if (PyErr_Occurred()) SWIG_fail;
26681 }
26682 {
26683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26684 }
26685 return resultobj;
26686 fail:
26687 return NULL;
26688 }
26689
26690
26691 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
26692 PyObject *resultobj;
26693 wxWindow *arg1 = (wxWindow *) 0 ;
26694 bool result;
26695 PyObject * obj0 = 0 ;
26696 char *kwnames[] = {
26697 (char *) "self", NULL
26698 };
26699
26700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
26701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26702 if (SWIG_arg_fail(1)) SWIG_fail;
26703 {
26704 PyThreadState* __tstate = wxPyBeginAllowThreads();
26705 result = (bool)(arg1)->Disable();
26706
26707 wxPyEndAllowThreads(__tstate);
26708 if (PyErr_Occurred()) SWIG_fail;
26709 }
26710 {
26711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26712 }
26713 return resultobj;
26714 fail:
26715 return NULL;
26716 }
26717
26718
26719 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
26720 PyObject *resultobj;
26721 wxWindow *arg1 = (wxWindow *) 0 ;
26722 bool result;
26723 PyObject * obj0 = 0 ;
26724 char *kwnames[] = {
26725 (char *) "self", NULL
26726 };
26727
26728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
26729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26730 if (SWIG_arg_fail(1)) SWIG_fail;
26731 {
26732 PyThreadState* __tstate = wxPyBeginAllowThreads();
26733 result = (bool)((wxWindow const *)arg1)->IsShown();
26734
26735 wxPyEndAllowThreads(__tstate);
26736 if (PyErr_Occurred()) SWIG_fail;
26737 }
26738 {
26739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26740 }
26741 return resultobj;
26742 fail:
26743 return NULL;
26744 }
26745
26746
26747 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
26748 PyObject *resultobj;
26749 wxWindow *arg1 = (wxWindow *) 0 ;
26750 bool result;
26751 PyObject * obj0 = 0 ;
26752 char *kwnames[] = {
26753 (char *) "self", NULL
26754 };
26755
26756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
26757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26758 if (SWIG_arg_fail(1)) SWIG_fail;
26759 {
26760 PyThreadState* __tstate = wxPyBeginAllowThreads();
26761 result = (bool)((wxWindow const *)arg1)->IsEnabled();
26762
26763 wxPyEndAllowThreads(__tstate);
26764 if (PyErr_Occurred()) SWIG_fail;
26765 }
26766 {
26767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26768 }
26769 return resultobj;
26770 fail:
26771 return NULL;
26772 }
26773
26774
26775 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26776 PyObject *resultobj;
26777 wxWindow *arg1 = (wxWindow *) 0 ;
26778 long arg2 ;
26779 PyObject * obj0 = 0 ;
26780 PyObject * obj1 = 0 ;
26781 char *kwnames[] = {
26782 (char *) "self",(char *) "style", NULL
26783 };
26784
26785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
26786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26787 if (SWIG_arg_fail(1)) SWIG_fail;
26788 {
26789 arg2 = (long)(SWIG_As_long(obj1));
26790 if (SWIG_arg_fail(2)) SWIG_fail;
26791 }
26792 {
26793 PyThreadState* __tstate = wxPyBeginAllowThreads();
26794 (arg1)->SetWindowStyleFlag(arg2);
26795
26796 wxPyEndAllowThreads(__tstate);
26797 if (PyErr_Occurred()) SWIG_fail;
26798 }
26799 Py_INCREF(Py_None); resultobj = Py_None;
26800 return resultobj;
26801 fail:
26802 return NULL;
26803 }
26804
26805
26806 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26807 PyObject *resultobj;
26808 wxWindow *arg1 = (wxWindow *) 0 ;
26809 long result;
26810 PyObject * obj0 = 0 ;
26811 char *kwnames[] = {
26812 (char *) "self", NULL
26813 };
26814
26815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
26816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26817 if (SWIG_arg_fail(1)) SWIG_fail;
26818 {
26819 PyThreadState* __tstate = wxPyBeginAllowThreads();
26820 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
26821
26822 wxPyEndAllowThreads(__tstate);
26823 if (PyErr_Occurred()) SWIG_fail;
26824 }
26825 {
26826 resultobj = SWIG_From_long((long)(result));
26827 }
26828 return resultobj;
26829 fail:
26830 return NULL;
26831 }
26832
26833
26834 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26835 PyObject *resultobj;
26836 wxWindow *arg1 = (wxWindow *) 0 ;
26837 int arg2 ;
26838 bool result;
26839 PyObject * obj0 = 0 ;
26840 PyObject * obj1 = 0 ;
26841 char *kwnames[] = {
26842 (char *) "self",(char *) "flag", NULL
26843 };
26844
26845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
26846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26847 if (SWIG_arg_fail(1)) SWIG_fail;
26848 {
26849 arg2 = (int)(SWIG_As_int(obj1));
26850 if (SWIG_arg_fail(2)) SWIG_fail;
26851 }
26852 {
26853 PyThreadState* __tstate = wxPyBeginAllowThreads();
26854 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
26855
26856 wxPyEndAllowThreads(__tstate);
26857 if (PyErr_Occurred()) SWIG_fail;
26858 }
26859 {
26860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26861 }
26862 return resultobj;
26863 fail:
26864 return NULL;
26865 }
26866
26867
26868 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
26869 PyObject *resultobj;
26870 wxWindow *arg1 = (wxWindow *) 0 ;
26871 bool result;
26872 PyObject * obj0 = 0 ;
26873 char *kwnames[] = {
26874 (char *) "self", NULL
26875 };
26876
26877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
26878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26879 if (SWIG_arg_fail(1)) SWIG_fail;
26880 {
26881 PyThreadState* __tstate = wxPyBeginAllowThreads();
26882 result = (bool)((wxWindow const *)arg1)->IsRetained();
26883
26884 wxPyEndAllowThreads(__tstate);
26885 if (PyErr_Occurred()) SWIG_fail;
26886 }
26887 {
26888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26889 }
26890 return resultobj;
26891 fail:
26892 return NULL;
26893 }
26894
26895
26896 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
26897 PyObject *resultobj;
26898 wxWindow *arg1 = (wxWindow *) 0 ;
26899 long arg2 ;
26900 PyObject * obj0 = 0 ;
26901 PyObject * obj1 = 0 ;
26902 char *kwnames[] = {
26903 (char *) "self",(char *) "exStyle", NULL
26904 };
26905
26906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
26907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26908 if (SWIG_arg_fail(1)) SWIG_fail;
26909 {
26910 arg2 = (long)(SWIG_As_long(obj1));
26911 if (SWIG_arg_fail(2)) SWIG_fail;
26912 }
26913 {
26914 PyThreadState* __tstate = wxPyBeginAllowThreads();
26915 (arg1)->SetExtraStyle(arg2);
26916
26917 wxPyEndAllowThreads(__tstate);
26918 if (PyErr_Occurred()) SWIG_fail;
26919 }
26920 Py_INCREF(Py_None); resultobj = Py_None;
26921 return resultobj;
26922 fail:
26923 return NULL;
26924 }
26925
26926
26927 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
26928 PyObject *resultobj;
26929 wxWindow *arg1 = (wxWindow *) 0 ;
26930 long result;
26931 PyObject * obj0 = 0 ;
26932 char *kwnames[] = {
26933 (char *) "self", NULL
26934 };
26935
26936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
26937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26938 if (SWIG_arg_fail(1)) SWIG_fail;
26939 {
26940 PyThreadState* __tstate = wxPyBeginAllowThreads();
26941 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
26942
26943 wxPyEndAllowThreads(__tstate);
26944 if (PyErr_Occurred()) SWIG_fail;
26945 }
26946 {
26947 resultobj = SWIG_From_long((long)(result));
26948 }
26949 return resultobj;
26950 fail:
26951 return NULL;
26952 }
26953
26954
26955 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
26956 PyObject *resultobj;
26957 wxWindow *arg1 = (wxWindow *) 0 ;
26958 bool arg2 = (bool) true ;
26959 PyObject * obj0 = 0 ;
26960 PyObject * obj1 = 0 ;
26961 char *kwnames[] = {
26962 (char *) "self",(char *) "modal", NULL
26963 };
26964
26965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
26966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26967 if (SWIG_arg_fail(1)) SWIG_fail;
26968 if (obj1) {
26969 {
26970 arg2 = (bool)(SWIG_As_bool(obj1));
26971 if (SWIG_arg_fail(2)) SWIG_fail;
26972 }
26973 }
26974 {
26975 PyThreadState* __tstate = wxPyBeginAllowThreads();
26976 (arg1)->MakeModal(arg2);
26977
26978 wxPyEndAllowThreads(__tstate);
26979 if (PyErr_Occurred()) SWIG_fail;
26980 }
26981 Py_INCREF(Py_None); resultobj = Py_None;
26982 return resultobj;
26983 fail:
26984 return NULL;
26985 }
26986
26987
26988 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
26989 PyObject *resultobj;
26990 wxWindow *arg1 = (wxWindow *) 0 ;
26991 bool arg2 ;
26992 PyObject * obj0 = 0 ;
26993 PyObject * obj1 = 0 ;
26994 char *kwnames[] = {
26995 (char *) "self",(char *) "enableTheme", NULL
26996 };
26997
26998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
26999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27000 if (SWIG_arg_fail(1)) SWIG_fail;
27001 {
27002 arg2 = (bool)(SWIG_As_bool(obj1));
27003 if (SWIG_arg_fail(2)) SWIG_fail;
27004 }
27005 {
27006 PyThreadState* __tstate = wxPyBeginAllowThreads();
27007 (arg1)->SetThemeEnabled(arg2);
27008
27009 wxPyEndAllowThreads(__tstate);
27010 if (PyErr_Occurred()) SWIG_fail;
27011 }
27012 Py_INCREF(Py_None); resultobj = Py_None;
27013 return resultobj;
27014 fail:
27015 return NULL;
27016 }
27017
27018
27019 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27020 PyObject *resultobj;
27021 wxWindow *arg1 = (wxWindow *) 0 ;
27022 bool result;
27023 PyObject * obj0 = 0 ;
27024 char *kwnames[] = {
27025 (char *) "self", NULL
27026 };
27027
27028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27030 if (SWIG_arg_fail(1)) SWIG_fail;
27031 {
27032 PyThreadState* __tstate = wxPyBeginAllowThreads();
27033 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27034
27035 wxPyEndAllowThreads(__tstate);
27036 if (PyErr_Occurred()) SWIG_fail;
27037 }
27038 {
27039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27040 }
27041 return resultobj;
27042 fail:
27043 return NULL;
27044 }
27045
27046
27047 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27048 PyObject *resultobj;
27049 wxWindow *arg1 = (wxWindow *) 0 ;
27050 PyObject * obj0 = 0 ;
27051 char *kwnames[] = {
27052 (char *) "self", NULL
27053 };
27054
27055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27057 if (SWIG_arg_fail(1)) SWIG_fail;
27058 {
27059 PyThreadState* __tstate = wxPyBeginAllowThreads();
27060 (arg1)->SetFocus();
27061
27062 wxPyEndAllowThreads(__tstate);
27063 if (PyErr_Occurred()) SWIG_fail;
27064 }
27065 Py_INCREF(Py_None); resultobj = Py_None;
27066 return resultobj;
27067 fail:
27068 return NULL;
27069 }
27070
27071
27072 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27073 PyObject *resultobj;
27074 wxWindow *arg1 = (wxWindow *) 0 ;
27075 PyObject * obj0 = 0 ;
27076 char *kwnames[] = {
27077 (char *) "self", NULL
27078 };
27079
27080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27082 if (SWIG_arg_fail(1)) SWIG_fail;
27083 {
27084 PyThreadState* __tstate = wxPyBeginAllowThreads();
27085 (arg1)->SetFocusFromKbd();
27086
27087 wxPyEndAllowThreads(__tstate);
27088 if (PyErr_Occurred()) SWIG_fail;
27089 }
27090 Py_INCREF(Py_None); resultobj = Py_None;
27091 return resultobj;
27092 fail:
27093 return NULL;
27094 }
27095
27096
27097 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27098 PyObject *resultobj;
27099 wxWindow *result;
27100 char *kwnames[] = {
27101 NULL
27102 };
27103
27104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27105 {
27106 if (!wxPyCheckForApp()) SWIG_fail;
27107 PyThreadState* __tstate = wxPyBeginAllowThreads();
27108 result = (wxWindow *)wxWindow::FindFocus();
27109
27110 wxPyEndAllowThreads(__tstate);
27111 if (PyErr_Occurred()) SWIG_fail;
27112 }
27113 {
27114 resultobj = wxPyMake_wxObject(result, 0);
27115 }
27116 return resultobj;
27117 fail:
27118 return NULL;
27119 }
27120
27121
27122 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27123 PyObject *resultobj;
27124 wxWindow *arg1 = (wxWindow *) 0 ;
27125 bool result;
27126 PyObject * obj0 = 0 ;
27127 char *kwnames[] = {
27128 (char *) "self", NULL
27129 };
27130
27131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27133 if (SWIG_arg_fail(1)) SWIG_fail;
27134 {
27135 PyThreadState* __tstate = wxPyBeginAllowThreads();
27136 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27137
27138 wxPyEndAllowThreads(__tstate);
27139 if (PyErr_Occurred()) SWIG_fail;
27140 }
27141 {
27142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27143 }
27144 return resultobj;
27145 fail:
27146 return NULL;
27147 }
27148
27149
27150 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27151 PyObject *resultobj;
27152 wxWindow *arg1 = (wxWindow *) 0 ;
27153 bool result;
27154 PyObject * obj0 = 0 ;
27155 char *kwnames[] = {
27156 (char *) "self", NULL
27157 };
27158
27159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27161 if (SWIG_arg_fail(1)) SWIG_fail;
27162 {
27163 PyThreadState* __tstate = wxPyBeginAllowThreads();
27164 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27165
27166 wxPyEndAllowThreads(__tstate);
27167 if (PyErr_Occurred()) SWIG_fail;
27168 }
27169 {
27170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27171 }
27172 return resultobj;
27173 fail:
27174 return NULL;
27175 }
27176
27177
27178 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27179 PyObject *resultobj;
27180 wxWindow *arg1 = (wxWindow *) 0 ;
27181 wxWindow *result;
27182 PyObject * obj0 = 0 ;
27183 char *kwnames[] = {
27184 (char *) "self", NULL
27185 };
27186
27187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27189 if (SWIG_arg_fail(1)) SWIG_fail;
27190 {
27191 PyThreadState* __tstate = wxPyBeginAllowThreads();
27192 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27193
27194 wxPyEndAllowThreads(__tstate);
27195 if (PyErr_Occurred()) SWIG_fail;
27196 }
27197 {
27198 resultobj = wxPyMake_wxObject(result, 0);
27199 }
27200 return resultobj;
27201 fail:
27202 return NULL;
27203 }
27204
27205
27206 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27207 PyObject *resultobj;
27208 wxWindow *arg1 = (wxWindow *) 0 ;
27209 wxWindow *arg2 = (wxWindow *) 0 ;
27210 wxWindow *result;
27211 PyObject * obj0 = 0 ;
27212 PyObject * obj1 = 0 ;
27213 char *kwnames[] = {
27214 (char *) "self",(char *) "child", NULL
27215 };
27216
27217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27219 if (SWIG_arg_fail(1)) SWIG_fail;
27220 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27221 if (SWIG_arg_fail(2)) SWIG_fail;
27222 {
27223 PyThreadState* __tstate = wxPyBeginAllowThreads();
27224 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27225
27226 wxPyEndAllowThreads(__tstate);
27227 if (PyErr_Occurred()) SWIG_fail;
27228 }
27229 {
27230 resultobj = wxPyMake_wxObject(result, 0);
27231 }
27232 return resultobj;
27233 fail:
27234 return NULL;
27235 }
27236
27237
27238 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27239 PyObject *resultobj;
27240 wxWindow *arg1 = (wxWindow *) 0 ;
27241 wxWindow *arg2 = (wxWindow *) 0 ;
27242 PyObject * obj0 = 0 ;
27243 PyObject * obj1 = 0 ;
27244 char *kwnames[] = {
27245 (char *) "self",(char *) "win", NULL
27246 };
27247
27248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27250 if (SWIG_arg_fail(1)) SWIG_fail;
27251 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27252 if (SWIG_arg_fail(2)) SWIG_fail;
27253 {
27254 PyThreadState* __tstate = wxPyBeginAllowThreads();
27255 (arg1)->SetTmpDefaultItem(arg2);
27256
27257 wxPyEndAllowThreads(__tstate);
27258 if (PyErr_Occurred()) SWIG_fail;
27259 }
27260 Py_INCREF(Py_None); resultobj = Py_None;
27261 return resultobj;
27262 fail:
27263 return NULL;
27264 }
27265
27266
27267 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27268 PyObject *resultobj;
27269 wxWindow *arg1 = (wxWindow *) 0 ;
27270 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27271 bool result;
27272 PyObject * obj0 = 0 ;
27273 PyObject * obj1 = 0 ;
27274 char *kwnames[] = {
27275 (char *) "self",(char *) "flags", NULL
27276 };
27277
27278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27280 if (SWIG_arg_fail(1)) SWIG_fail;
27281 if (obj1) {
27282 {
27283 arg2 = (int)(SWIG_As_int(obj1));
27284 if (SWIG_arg_fail(2)) SWIG_fail;
27285 }
27286 }
27287 {
27288 PyThreadState* __tstate = wxPyBeginAllowThreads();
27289 result = (bool)(arg1)->Navigate(arg2);
27290
27291 wxPyEndAllowThreads(__tstate);
27292 if (PyErr_Occurred()) SWIG_fail;
27293 }
27294 {
27295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27296 }
27297 return resultobj;
27298 fail:
27299 return NULL;
27300 }
27301
27302
27303 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27304 PyObject *resultobj;
27305 wxWindow *arg1 = (wxWindow *) 0 ;
27306 wxWindow *arg2 = (wxWindow *) 0 ;
27307 PyObject * obj0 = 0 ;
27308 PyObject * obj1 = 0 ;
27309 char *kwnames[] = {
27310 (char *) "self",(char *) "win", NULL
27311 };
27312
27313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27315 if (SWIG_arg_fail(1)) SWIG_fail;
27316 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27317 if (SWIG_arg_fail(2)) SWIG_fail;
27318 {
27319 PyThreadState* __tstate = wxPyBeginAllowThreads();
27320 (arg1)->MoveAfterInTabOrder(arg2);
27321
27322 wxPyEndAllowThreads(__tstate);
27323 if (PyErr_Occurred()) SWIG_fail;
27324 }
27325 Py_INCREF(Py_None); resultobj = Py_None;
27326 return resultobj;
27327 fail:
27328 return NULL;
27329 }
27330
27331
27332 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27333 PyObject *resultobj;
27334 wxWindow *arg1 = (wxWindow *) 0 ;
27335 wxWindow *arg2 = (wxWindow *) 0 ;
27336 PyObject * obj0 = 0 ;
27337 PyObject * obj1 = 0 ;
27338 char *kwnames[] = {
27339 (char *) "self",(char *) "win", NULL
27340 };
27341
27342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27344 if (SWIG_arg_fail(1)) SWIG_fail;
27345 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27346 if (SWIG_arg_fail(2)) SWIG_fail;
27347 {
27348 PyThreadState* __tstate = wxPyBeginAllowThreads();
27349 (arg1)->MoveBeforeInTabOrder(arg2);
27350
27351 wxPyEndAllowThreads(__tstate);
27352 if (PyErr_Occurred()) SWIG_fail;
27353 }
27354 Py_INCREF(Py_None); resultobj = Py_None;
27355 return resultobj;
27356 fail:
27357 return NULL;
27358 }
27359
27360
27361 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27362 PyObject *resultobj;
27363 wxWindow *arg1 = (wxWindow *) 0 ;
27364 PyObject *result;
27365 PyObject * obj0 = 0 ;
27366 char *kwnames[] = {
27367 (char *) "self", NULL
27368 };
27369
27370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27372 if (SWIG_arg_fail(1)) SWIG_fail;
27373 {
27374 PyThreadState* __tstate = wxPyBeginAllowThreads();
27375 result = (PyObject *)wxWindow_GetChildren(arg1);
27376
27377 wxPyEndAllowThreads(__tstate);
27378 if (PyErr_Occurred()) SWIG_fail;
27379 }
27380 resultobj = result;
27381 return resultobj;
27382 fail:
27383 return NULL;
27384 }
27385
27386
27387 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27388 PyObject *resultobj;
27389 wxWindow *arg1 = (wxWindow *) 0 ;
27390 wxWindow *result;
27391 PyObject * obj0 = 0 ;
27392 char *kwnames[] = {
27393 (char *) "self", NULL
27394 };
27395
27396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27398 if (SWIG_arg_fail(1)) SWIG_fail;
27399 {
27400 PyThreadState* __tstate = wxPyBeginAllowThreads();
27401 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27402
27403 wxPyEndAllowThreads(__tstate);
27404 if (PyErr_Occurred()) SWIG_fail;
27405 }
27406 {
27407 resultobj = wxPyMake_wxObject(result, 0);
27408 }
27409 return resultobj;
27410 fail:
27411 return NULL;
27412 }
27413
27414
27415 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27416 PyObject *resultobj;
27417 wxWindow *arg1 = (wxWindow *) 0 ;
27418 wxWindow *result;
27419 PyObject * obj0 = 0 ;
27420 char *kwnames[] = {
27421 (char *) "self", NULL
27422 };
27423
27424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27426 if (SWIG_arg_fail(1)) SWIG_fail;
27427 {
27428 PyThreadState* __tstate = wxPyBeginAllowThreads();
27429 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27430
27431 wxPyEndAllowThreads(__tstate);
27432 if (PyErr_Occurred()) SWIG_fail;
27433 }
27434 {
27435 resultobj = wxPyMake_wxObject(result, 0);
27436 }
27437 return resultobj;
27438 fail:
27439 return NULL;
27440 }
27441
27442
27443 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27444 PyObject *resultobj;
27445 wxWindow *arg1 = (wxWindow *) 0 ;
27446 bool result;
27447 PyObject * obj0 = 0 ;
27448 char *kwnames[] = {
27449 (char *) "self", NULL
27450 };
27451
27452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27454 if (SWIG_arg_fail(1)) SWIG_fail;
27455 {
27456 PyThreadState* __tstate = wxPyBeginAllowThreads();
27457 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
27458
27459 wxPyEndAllowThreads(__tstate);
27460 if (PyErr_Occurred()) SWIG_fail;
27461 }
27462 {
27463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27464 }
27465 return resultobj;
27466 fail:
27467 return NULL;
27468 }
27469
27470
27471 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
27472 PyObject *resultobj;
27473 wxWindow *arg1 = (wxWindow *) 0 ;
27474 wxWindow *arg2 = (wxWindow *) 0 ;
27475 bool result;
27476 PyObject * obj0 = 0 ;
27477 PyObject * obj1 = 0 ;
27478 char *kwnames[] = {
27479 (char *) "self",(char *) "newParent", NULL
27480 };
27481
27482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
27483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27484 if (SWIG_arg_fail(1)) SWIG_fail;
27485 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27486 if (SWIG_arg_fail(2)) SWIG_fail;
27487 {
27488 PyThreadState* __tstate = wxPyBeginAllowThreads();
27489 result = (bool)(arg1)->Reparent(arg2);
27490
27491 wxPyEndAllowThreads(__tstate);
27492 if (PyErr_Occurred()) SWIG_fail;
27493 }
27494 {
27495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27496 }
27497 return resultobj;
27498 fail:
27499 return NULL;
27500 }
27501
27502
27503 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
27504 PyObject *resultobj;
27505 wxWindow *arg1 = (wxWindow *) 0 ;
27506 wxWindow *arg2 = (wxWindow *) 0 ;
27507 PyObject * obj0 = 0 ;
27508 PyObject * obj1 = 0 ;
27509 char *kwnames[] = {
27510 (char *) "self",(char *) "child", NULL
27511 };
27512
27513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
27514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27515 if (SWIG_arg_fail(1)) SWIG_fail;
27516 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27517 if (SWIG_arg_fail(2)) SWIG_fail;
27518 {
27519 PyThreadState* __tstate = wxPyBeginAllowThreads();
27520 (arg1)->AddChild(arg2);
27521
27522 wxPyEndAllowThreads(__tstate);
27523 if (PyErr_Occurred()) SWIG_fail;
27524 }
27525 Py_INCREF(Py_None); resultobj = Py_None;
27526 return resultobj;
27527 fail:
27528 return NULL;
27529 }
27530
27531
27532 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
27533 PyObject *resultobj;
27534 wxWindow *arg1 = (wxWindow *) 0 ;
27535 wxWindow *arg2 = (wxWindow *) 0 ;
27536 PyObject * obj0 = 0 ;
27537 PyObject * obj1 = 0 ;
27538 char *kwnames[] = {
27539 (char *) "self",(char *) "child", NULL
27540 };
27541
27542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
27543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27544 if (SWIG_arg_fail(1)) SWIG_fail;
27545 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27546 if (SWIG_arg_fail(2)) SWIG_fail;
27547 {
27548 PyThreadState* __tstate = wxPyBeginAllowThreads();
27549 (arg1)->RemoveChild(arg2);
27550
27551 wxPyEndAllowThreads(__tstate);
27552 if (PyErr_Occurred()) SWIG_fail;
27553 }
27554 Py_INCREF(Py_None); resultobj = Py_None;
27555 return resultobj;
27556 fail:
27557 return NULL;
27558 }
27559
27560
27561 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
27562 PyObject *resultobj;
27563 wxWindow *arg1 = (wxWindow *) 0 ;
27564 long arg2 ;
27565 wxWindow *result;
27566 PyObject * obj0 = 0 ;
27567 PyObject * obj1 = 0 ;
27568 char *kwnames[] = {
27569 (char *) "self",(char *) "winid", NULL
27570 };
27571
27572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
27573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27574 if (SWIG_arg_fail(1)) SWIG_fail;
27575 {
27576 arg2 = (long)(SWIG_As_long(obj1));
27577 if (SWIG_arg_fail(2)) SWIG_fail;
27578 }
27579 {
27580 PyThreadState* __tstate = wxPyBeginAllowThreads();
27581 result = (wxWindow *)(arg1)->FindWindow(arg2);
27582
27583 wxPyEndAllowThreads(__tstate);
27584 if (PyErr_Occurred()) SWIG_fail;
27585 }
27586 {
27587 resultobj = wxPyMake_wxObject(result, 0);
27588 }
27589 return resultobj;
27590 fail:
27591 return NULL;
27592 }
27593
27594
27595 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
27596 PyObject *resultobj;
27597 wxWindow *arg1 = (wxWindow *) 0 ;
27598 wxString *arg2 = 0 ;
27599 wxWindow *result;
27600 bool temp2 = false ;
27601 PyObject * obj0 = 0 ;
27602 PyObject * obj1 = 0 ;
27603 char *kwnames[] = {
27604 (char *) "self",(char *) "name", NULL
27605 };
27606
27607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
27608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27609 if (SWIG_arg_fail(1)) SWIG_fail;
27610 {
27611 arg2 = wxString_in_helper(obj1);
27612 if (arg2 == NULL) SWIG_fail;
27613 temp2 = true;
27614 }
27615 {
27616 PyThreadState* __tstate = wxPyBeginAllowThreads();
27617 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
27618
27619 wxPyEndAllowThreads(__tstate);
27620 if (PyErr_Occurred()) SWIG_fail;
27621 }
27622 {
27623 resultobj = wxPyMake_wxObject(result, 0);
27624 }
27625 {
27626 if (temp2)
27627 delete arg2;
27628 }
27629 return resultobj;
27630 fail:
27631 {
27632 if (temp2)
27633 delete arg2;
27634 }
27635 return NULL;
27636 }
27637
27638
27639 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27640 PyObject *resultobj;
27641 wxWindow *arg1 = (wxWindow *) 0 ;
27642 wxEvtHandler *result;
27643 PyObject * obj0 = 0 ;
27644 char *kwnames[] = {
27645 (char *) "self", NULL
27646 };
27647
27648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
27649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27650 if (SWIG_arg_fail(1)) SWIG_fail;
27651 {
27652 PyThreadState* __tstate = wxPyBeginAllowThreads();
27653 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
27654
27655 wxPyEndAllowThreads(__tstate);
27656 if (PyErr_Occurred()) SWIG_fail;
27657 }
27658 {
27659 resultobj = wxPyMake_wxObject(result, 0);
27660 }
27661 return resultobj;
27662 fail:
27663 return NULL;
27664 }
27665
27666
27667 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27668 PyObject *resultobj;
27669 wxWindow *arg1 = (wxWindow *) 0 ;
27670 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27671 PyObject * obj0 = 0 ;
27672 PyObject * obj1 = 0 ;
27673 char *kwnames[] = {
27674 (char *) "self",(char *) "handler", NULL
27675 };
27676
27677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
27678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27679 if (SWIG_arg_fail(1)) SWIG_fail;
27680 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27681 if (SWIG_arg_fail(2)) SWIG_fail;
27682 {
27683 PyThreadState* __tstate = wxPyBeginAllowThreads();
27684 (arg1)->SetEventHandler(arg2);
27685
27686 wxPyEndAllowThreads(__tstate);
27687 if (PyErr_Occurred()) SWIG_fail;
27688 }
27689 Py_INCREF(Py_None); resultobj = Py_None;
27690 return resultobj;
27691 fail:
27692 return NULL;
27693 }
27694
27695
27696 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27697 PyObject *resultobj;
27698 wxWindow *arg1 = (wxWindow *) 0 ;
27699 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27700 PyObject * obj0 = 0 ;
27701 PyObject * obj1 = 0 ;
27702 char *kwnames[] = {
27703 (char *) "self",(char *) "handler", NULL
27704 };
27705
27706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
27707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27708 if (SWIG_arg_fail(1)) SWIG_fail;
27709 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27710 if (SWIG_arg_fail(2)) SWIG_fail;
27711 {
27712 PyThreadState* __tstate = wxPyBeginAllowThreads();
27713 (arg1)->PushEventHandler(arg2);
27714
27715 wxPyEndAllowThreads(__tstate);
27716 if (PyErr_Occurred()) SWIG_fail;
27717 }
27718 Py_INCREF(Py_None); resultobj = Py_None;
27719 return resultobj;
27720 fail:
27721 return NULL;
27722 }
27723
27724
27725 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27726 PyObject *resultobj;
27727 wxWindow *arg1 = (wxWindow *) 0 ;
27728 bool arg2 = (bool) false ;
27729 wxEvtHandler *result;
27730 PyObject * obj0 = 0 ;
27731 PyObject * obj1 = 0 ;
27732 char *kwnames[] = {
27733 (char *) "self",(char *) "deleteHandler", NULL
27734 };
27735
27736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
27737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27738 if (SWIG_arg_fail(1)) SWIG_fail;
27739 if (obj1) {
27740 {
27741 arg2 = (bool)(SWIG_As_bool(obj1));
27742 if (SWIG_arg_fail(2)) SWIG_fail;
27743 }
27744 }
27745 {
27746 PyThreadState* __tstate = wxPyBeginAllowThreads();
27747 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
27748
27749 wxPyEndAllowThreads(__tstate);
27750 if (PyErr_Occurred()) SWIG_fail;
27751 }
27752 {
27753 resultobj = wxPyMake_wxObject(result, 0);
27754 }
27755 return resultobj;
27756 fail:
27757 return NULL;
27758 }
27759
27760
27761 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27762 PyObject *resultobj;
27763 wxWindow *arg1 = (wxWindow *) 0 ;
27764 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27765 bool result;
27766 PyObject * obj0 = 0 ;
27767 PyObject * obj1 = 0 ;
27768 char *kwnames[] = {
27769 (char *) "self",(char *) "handler", NULL
27770 };
27771
27772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
27773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27774 if (SWIG_arg_fail(1)) SWIG_fail;
27775 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27776 if (SWIG_arg_fail(2)) SWIG_fail;
27777 {
27778 PyThreadState* __tstate = wxPyBeginAllowThreads();
27779 result = (bool)(arg1)->RemoveEventHandler(arg2);
27780
27781 wxPyEndAllowThreads(__tstate);
27782 if (PyErr_Occurred()) SWIG_fail;
27783 }
27784 {
27785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27786 }
27787 return resultobj;
27788 fail:
27789 return NULL;
27790 }
27791
27792
27793 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
27794 PyObject *resultobj;
27795 wxWindow *arg1 = (wxWindow *) 0 ;
27796 wxValidator *arg2 = 0 ;
27797 PyObject * obj0 = 0 ;
27798 PyObject * obj1 = 0 ;
27799 char *kwnames[] = {
27800 (char *) "self",(char *) "validator", NULL
27801 };
27802
27803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
27804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27805 if (SWIG_arg_fail(1)) SWIG_fail;
27806 {
27807 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
27808 if (SWIG_arg_fail(2)) SWIG_fail;
27809 if (arg2 == NULL) {
27810 SWIG_null_ref("wxValidator");
27811 }
27812 if (SWIG_arg_fail(2)) SWIG_fail;
27813 }
27814 {
27815 PyThreadState* __tstate = wxPyBeginAllowThreads();
27816 (arg1)->SetValidator((wxValidator const &)*arg2);
27817
27818 wxPyEndAllowThreads(__tstate);
27819 if (PyErr_Occurred()) SWIG_fail;
27820 }
27821 Py_INCREF(Py_None); resultobj = Py_None;
27822 return resultobj;
27823 fail:
27824 return NULL;
27825 }
27826
27827
27828 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
27829 PyObject *resultobj;
27830 wxWindow *arg1 = (wxWindow *) 0 ;
27831 wxValidator *result;
27832 PyObject * obj0 = 0 ;
27833 char *kwnames[] = {
27834 (char *) "self", NULL
27835 };
27836
27837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
27838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27839 if (SWIG_arg_fail(1)) SWIG_fail;
27840 {
27841 PyThreadState* __tstate = wxPyBeginAllowThreads();
27842 result = (wxValidator *)(arg1)->GetValidator();
27843
27844 wxPyEndAllowThreads(__tstate);
27845 if (PyErr_Occurred()) SWIG_fail;
27846 }
27847 {
27848 resultobj = wxPyMake_wxObject(result, 0);
27849 }
27850 return resultobj;
27851 fail:
27852 return NULL;
27853 }
27854
27855
27856 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
27857 PyObject *resultobj;
27858 wxWindow *arg1 = (wxWindow *) 0 ;
27859 bool result;
27860 PyObject * obj0 = 0 ;
27861 char *kwnames[] = {
27862 (char *) "self", NULL
27863 };
27864
27865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
27866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27867 if (SWIG_arg_fail(1)) SWIG_fail;
27868 {
27869 PyThreadState* __tstate = wxPyBeginAllowThreads();
27870 result = (bool)(arg1)->Validate();
27871
27872 wxPyEndAllowThreads(__tstate);
27873 if (PyErr_Occurred()) SWIG_fail;
27874 }
27875 {
27876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27877 }
27878 return resultobj;
27879 fail:
27880 return NULL;
27881 }
27882
27883
27884 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
27885 PyObject *resultobj;
27886 wxWindow *arg1 = (wxWindow *) 0 ;
27887 bool result;
27888 PyObject * obj0 = 0 ;
27889 char *kwnames[] = {
27890 (char *) "self", NULL
27891 };
27892
27893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
27894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27895 if (SWIG_arg_fail(1)) SWIG_fail;
27896 {
27897 PyThreadState* __tstate = wxPyBeginAllowThreads();
27898 result = (bool)(arg1)->TransferDataToWindow();
27899
27900 wxPyEndAllowThreads(__tstate);
27901 if (PyErr_Occurred()) SWIG_fail;
27902 }
27903 {
27904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27905 }
27906 return resultobj;
27907 fail:
27908 return NULL;
27909 }
27910
27911
27912 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
27913 PyObject *resultobj;
27914 wxWindow *arg1 = (wxWindow *) 0 ;
27915 bool result;
27916 PyObject * obj0 = 0 ;
27917 char *kwnames[] = {
27918 (char *) "self", NULL
27919 };
27920
27921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
27922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27923 if (SWIG_arg_fail(1)) SWIG_fail;
27924 {
27925 PyThreadState* __tstate = wxPyBeginAllowThreads();
27926 result = (bool)(arg1)->TransferDataFromWindow();
27927
27928 wxPyEndAllowThreads(__tstate);
27929 if (PyErr_Occurred()) SWIG_fail;
27930 }
27931 {
27932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27933 }
27934 return resultobj;
27935 fail:
27936 return NULL;
27937 }
27938
27939
27940 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
27941 PyObject *resultobj;
27942 wxWindow *arg1 = (wxWindow *) 0 ;
27943 PyObject * obj0 = 0 ;
27944 char *kwnames[] = {
27945 (char *) "self", NULL
27946 };
27947
27948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
27949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27950 if (SWIG_arg_fail(1)) SWIG_fail;
27951 {
27952 PyThreadState* __tstate = wxPyBeginAllowThreads();
27953 (arg1)->InitDialog();
27954
27955 wxPyEndAllowThreads(__tstate);
27956 if (PyErr_Occurred()) SWIG_fail;
27957 }
27958 Py_INCREF(Py_None); resultobj = Py_None;
27959 return resultobj;
27960 fail:
27961 return NULL;
27962 }
27963
27964
27965 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
27966 PyObject *resultobj;
27967 wxWindow *arg1 = (wxWindow *) 0 ;
27968 wxAcceleratorTable *arg2 = 0 ;
27969 PyObject * obj0 = 0 ;
27970 PyObject * obj1 = 0 ;
27971 char *kwnames[] = {
27972 (char *) "self",(char *) "accel", NULL
27973 };
27974
27975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
27976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27977 if (SWIG_arg_fail(1)) SWIG_fail;
27978 {
27979 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
27980 if (SWIG_arg_fail(2)) SWIG_fail;
27981 if (arg2 == NULL) {
27982 SWIG_null_ref("wxAcceleratorTable");
27983 }
27984 if (SWIG_arg_fail(2)) SWIG_fail;
27985 }
27986 {
27987 PyThreadState* __tstate = wxPyBeginAllowThreads();
27988 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
27989
27990 wxPyEndAllowThreads(__tstate);
27991 if (PyErr_Occurred()) SWIG_fail;
27992 }
27993 Py_INCREF(Py_None); resultobj = Py_None;
27994 return resultobj;
27995 fail:
27996 return NULL;
27997 }
27998
27999
28000 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28001 PyObject *resultobj;
28002 wxWindow *arg1 = (wxWindow *) 0 ;
28003 wxAcceleratorTable *result;
28004 PyObject * obj0 = 0 ;
28005 char *kwnames[] = {
28006 (char *) "self", NULL
28007 };
28008
28009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28011 if (SWIG_arg_fail(1)) SWIG_fail;
28012 {
28013 PyThreadState* __tstate = wxPyBeginAllowThreads();
28014 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28015
28016 wxPyEndAllowThreads(__tstate);
28017 if (PyErr_Occurred()) SWIG_fail;
28018 }
28019 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28020 return resultobj;
28021 fail:
28022 return NULL;
28023 }
28024
28025
28026 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28027 PyObject *resultobj;
28028 wxWindow *arg1 = (wxWindow *) 0 ;
28029 int arg2 ;
28030 int arg3 ;
28031 int arg4 ;
28032 bool result;
28033 PyObject * obj0 = 0 ;
28034 PyObject * obj1 = 0 ;
28035 PyObject * obj2 = 0 ;
28036 PyObject * obj3 = 0 ;
28037 char *kwnames[] = {
28038 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28039 };
28040
28041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28043 if (SWIG_arg_fail(1)) SWIG_fail;
28044 {
28045 arg2 = (int)(SWIG_As_int(obj1));
28046 if (SWIG_arg_fail(2)) SWIG_fail;
28047 }
28048 {
28049 arg3 = (int)(SWIG_As_int(obj2));
28050 if (SWIG_arg_fail(3)) SWIG_fail;
28051 }
28052 {
28053 arg4 = (int)(SWIG_As_int(obj3));
28054 if (SWIG_arg_fail(4)) SWIG_fail;
28055 }
28056 {
28057 PyThreadState* __tstate = wxPyBeginAllowThreads();
28058 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28059
28060 wxPyEndAllowThreads(__tstate);
28061 if (PyErr_Occurred()) SWIG_fail;
28062 }
28063 {
28064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28065 }
28066 return resultobj;
28067 fail:
28068 return NULL;
28069 }
28070
28071
28072 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28073 PyObject *resultobj;
28074 wxWindow *arg1 = (wxWindow *) 0 ;
28075 int arg2 ;
28076 bool result;
28077 PyObject * obj0 = 0 ;
28078 PyObject * obj1 = 0 ;
28079 char *kwnames[] = {
28080 (char *) "self",(char *) "hotkeyId", NULL
28081 };
28082
28083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28085 if (SWIG_arg_fail(1)) SWIG_fail;
28086 {
28087 arg2 = (int)(SWIG_As_int(obj1));
28088 if (SWIG_arg_fail(2)) SWIG_fail;
28089 }
28090 {
28091 PyThreadState* __tstate = wxPyBeginAllowThreads();
28092 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28093
28094 wxPyEndAllowThreads(__tstate);
28095 if (PyErr_Occurred()) SWIG_fail;
28096 }
28097 {
28098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28099 }
28100 return resultobj;
28101 fail:
28102 return NULL;
28103 }
28104
28105
28106 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28107 PyObject *resultobj;
28108 wxWindow *arg1 = (wxWindow *) 0 ;
28109 wxPoint *arg2 = 0 ;
28110 wxPoint result;
28111 wxPoint temp2 ;
28112 PyObject * obj0 = 0 ;
28113 PyObject * obj1 = 0 ;
28114 char *kwnames[] = {
28115 (char *) "self",(char *) "pt", NULL
28116 };
28117
28118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28120 if (SWIG_arg_fail(1)) SWIG_fail;
28121 {
28122 arg2 = &temp2;
28123 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28124 }
28125 {
28126 PyThreadState* __tstate = wxPyBeginAllowThreads();
28127 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28128
28129 wxPyEndAllowThreads(__tstate);
28130 if (PyErr_Occurred()) SWIG_fail;
28131 }
28132 {
28133 wxPoint * resultptr;
28134 resultptr = new wxPoint((wxPoint &)(result));
28135 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28136 }
28137 return resultobj;
28138 fail:
28139 return NULL;
28140 }
28141
28142
28143 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28144 PyObject *resultobj;
28145 wxWindow *arg1 = (wxWindow *) 0 ;
28146 wxSize *arg2 = 0 ;
28147 wxSize result;
28148 wxSize temp2 ;
28149 PyObject * obj0 = 0 ;
28150 PyObject * obj1 = 0 ;
28151 char *kwnames[] = {
28152 (char *) "self",(char *) "sz", NULL
28153 };
28154
28155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28157 if (SWIG_arg_fail(1)) SWIG_fail;
28158 {
28159 arg2 = &temp2;
28160 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28161 }
28162 {
28163 PyThreadState* __tstate = wxPyBeginAllowThreads();
28164 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28165
28166 wxPyEndAllowThreads(__tstate);
28167 if (PyErr_Occurred()) SWIG_fail;
28168 }
28169 {
28170 wxSize * resultptr;
28171 resultptr = new wxSize((wxSize &)(result));
28172 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28173 }
28174 return resultobj;
28175 fail:
28176 return NULL;
28177 }
28178
28179
28180 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28181 PyObject *resultobj;
28182 wxWindow *arg1 = (wxWindow *) 0 ;
28183 wxPoint *arg2 = 0 ;
28184 wxPoint result;
28185 wxPoint temp2 ;
28186 PyObject * obj0 = 0 ;
28187 PyObject * obj1 = 0 ;
28188 char *kwnames[] = {
28189 (char *) "self",(char *) "pt", NULL
28190 };
28191
28192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28194 if (SWIG_arg_fail(1)) SWIG_fail;
28195 {
28196 arg2 = &temp2;
28197 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28198 }
28199 {
28200 PyThreadState* __tstate = wxPyBeginAllowThreads();
28201 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28202
28203 wxPyEndAllowThreads(__tstate);
28204 if (PyErr_Occurred()) SWIG_fail;
28205 }
28206 {
28207 wxPoint * resultptr;
28208 resultptr = new wxPoint((wxPoint &)(result));
28209 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28210 }
28211 return resultobj;
28212 fail:
28213 return NULL;
28214 }
28215
28216
28217 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28218 PyObject *resultobj;
28219 wxWindow *arg1 = (wxWindow *) 0 ;
28220 wxSize *arg2 = 0 ;
28221 wxSize result;
28222 wxSize temp2 ;
28223 PyObject * obj0 = 0 ;
28224 PyObject * obj1 = 0 ;
28225 char *kwnames[] = {
28226 (char *) "self",(char *) "sz", NULL
28227 };
28228
28229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28231 if (SWIG_arg_fail(1)) SWIG_fail;
28232 {
28233 arg2 = &temp2;
28234 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28235 }
28236 {
28237 PyThreadState* __tstate = wxPyBeginAllowThreads();
28238 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28239
28240 wxPyEndAllowThreads(__tstate);
28241 if (PyErr_Occurred()) SWIG_fail;
28242 }
28243 {
28244 wxSize * resultptr;
28245 resultptr = new wxSize((wxSize &)(result));
28246 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28247 }
28248 return resultobj;
28249 fail:
28250 return NULL;
28251 }
28252
28253
28254 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28255 PyObject *resultobj;
28256 wxWindow *arg1 = (wxWindow *) 0 ;
28257 wxPoint *arg2 = 0 ;
28258 wxPoint result;
28259 wxPoint temp2 ;
28260 PyObject * obj0 = 0 ;
28261 PyObject * obj1 = 0 ;
28262 char *kwnames[] = {
28263 (char *) "self",(char *) "pt", NULL
28264 };
28265
28266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28268 if (SWIG_arg_fail(1)) SWIG_fail;
28269 {
28270 arg2 = &temp2;
28271 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28272 }
28273 {
28274 PyThreadState* __tstate = wxPyBeginAllowThreads();
28275 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28276
28277 wxPyEndAllowThreads(__tstate);
28278 if (PyErr_Occurred()) SWIG_fail;
28279 }
28280 {
28281 wxPoint * resultptr;
28282 resultptr = new wxPoint((wxPoint &)(result));
28283 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28284 }
28285 return resultobj;
28286 fail:
28287 return NULL;
28288 }
28289
28290
28291 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28292 PyObject *resultobj;
28293 wxWindow *arg1 = (wxWindow *) 0 ;
28294 wxSize *arg2 = 0 ;
28295 wxSize result;
28296 wxSize temp2 ;
28297 PyObject * obj0 = 0 ;
28298 PyObject * obj1 = 0 ;
28299 char *kwnames[] = {
28300 (char *) "self",(char *) "sz", NULL
28301 };
28302
28303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
28304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28305 if (SWIG_arg_fail(1)) SWIG_fail;
28306 {
28307 arg2 = &temp2;
28308 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28309 }
28310 {
28311 PyThreadState* __tstate = wxPyBeginAllowThreads();
28312 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28313
28314 wxPyEndAllowThreads(__tstate);
28315 if (PyErr_Occurred()) SWIG_fail;
28316 }
28317 {
28318 wxSize * resultptr;
28319 resultptr = new wxSize((wxSize &)(result));
28320 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28321 }
28322 return resultobj;
28323 fail:
28324 return NULL;
28325 }
28326
28327
28328 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28329 PyObject *resultobj;
28330 wxWindow *arg1 = (wxWindow *) 0 ;
28331 int arg2 ;
28332 int arg3 ;
28333 PyObject * obj0 = 0 ;
28334 PyObject * obj1 = 0 ;
28335 PyObject * obj2 = 0 ;
28336 char *kwnames[] = {
28337 (char *) "self",(char *) "x",(char *) "y", NULL
28338 };
28339
28340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28342 if (SWIG_arg_fail(1)) SWIG_fail;
28343 {
28344 arg2 = (int)(SWIG_As_int(obj1));
28345 if (SWIG_arg_fail(2)) SWIG_fail;
28346 }
28347 {
28348 arg3 = (int)(SWIG_As_int(obj2));
28349 if (SWIG_arg_fail(3)) SWIG_fail;
28350 }
28351 {
28352 PyThreadState* __tstate = wxPyBeginAllowThreads();
28353 (arg1)->WarpPointer(arg2,arg3);
28354
28355 wxPyEndAllowThreads(__tstate);
28356 if (PyErr_Occurred()) SWIG_fail;
28357 }
28358 Py_INCREF(Py_None); resultobj = Py_None;
28359 return resultobj;
28360 fail:
28361 return NULL;
28362 }
28363
28364
28365 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28366 PyObject *resultobj;
28367 wxWindow *arg1 = (wxWindow *) 0 ;
28368 PyObject * obj0 = 0 ;
28369 char *kwnames[] = {
28370 (char *) "self", NULL
28371 };
28372
28373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28375 if (SWIG_arg_fail(1)) SWIG_fail;
28376 {
28377 PyThreadState* __tstate = wxPyBeginAllowThreads();
28378 (arg1)->CaptureMouse();
28379
28380 wxPyEndAllowThreads(__tstate);
28381 if (PyErr_Occurred()) SWIG_fail;
28382 }
28383 Py_INCREF(Py_None); resultobj = Py_None;
28384 return resultobj;
28385 fail:
28386 return NULL;
28387 }
28388
28389
28390 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28391 PyObject *resultobj;
28392 wxWindow *arg1 = (wxWindow *) 0 ;
28393 PyObject * obj0 = 0 ;
28394 char *kwnames[] = {
28395 (char *) "self", NULL
28396 };
28397
28398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28400 if (SWIG_arg_fail(1)) SWIG_fail;
28401 {
28402 PyThreadState* __tstate = wxPyBeginAllowThreads();
28403 (arg1)->ReleaseMouse();
28404
28405 wxPyEndAllowThreads(__tstate);
28406 if (PyErr_Occurred()) SWIG_fail;
28407 }
28408 Py_INCREF(Py_None); resultobj = Py_None;
28409 return resultobj;
28410 fail:
28411 return NULL;
28412 }
28413
28414
28415 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28416 PyObject *resultobj;
28417 wxWindow *result;
28418 char *kwnames[] = {
28419 NULL
28420 };
28421
28422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28423 {
28424 if (!wxPyCheckForApp()) SWIG_fail;
28425 PyThreadState* __tstate = wxPyBeginAllowThreads();
28426 result = (wxWindow *)wxWindow::GetCapture();
28427
28428 wxPyEndAllowThreads(__tstate);
28429 if (PyErr_Occurred()) SWIG_fail;
28430 }
28431 {
28432 resultobj = wxPyMake_wxObject(result, 0);
28433 }
28434 return resultobj;
28435 fail:
28436 return NULL;
28437 }
28438
28439
28440 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28441 PyObject *resultobj;
28442 wxWindow *arg1 = (wxWindow *) 0 ;
28443 bool result;
28444 PyObject * obj0 = 0 ;
28445 char *kwnames[] = {
28446 (char *) "self", NULL
28447 };
28448
28449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28451 if (SWIG_arg_fail(1)) SWIG_fail;
28452 {
28453 PyThreadState* __tstate = wxPyBeginAllowThreads();
28454 result = (bool)((wxWindow const *)arg1)->HasCapture();
28455
28456 wxPyEndAllowThreads(__tstate);
28457 if (PyErr_Occurred()) SWIG_fail;
28458 }
28459 {
28460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28461 }
28462 return resultobj;
28463 fail:
28464 return NULL;
28465 }
28466
28467
28468 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
28469 PyObject *resultobj;
28470 wxWindow *arg1 = (wxWindow *) 0 ;
28471 bool arg2 = (bool) true ;
28472 wxRect *arg3 = (wxRect *) NULL ;
28473 PyObject * obj0 = 0 ;
28474 PyObject * obj1 = 0 ;
28475 PyObject * obj2 = 0 ;
28476 char *kwnames[] = {
28477 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
28478 };
28479
28480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
28481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28482 if (SWIG_arg_fail(1)) SWIG_fail;
28483 if (obj1) {
28484 {
28485 arg2 = (bool)(SWIG_As_bool(obj1));
28486 if (SWIG_arg_fail(2)) SWIG_fail;
28487 }
28488 }
28489 if (obj2) {
28490 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
28491 if (SWIG_arg_fail(3)) SWIG_fail;
28492 }
28493 {
28494 PyThreadState* __tstate = wxPyBeginAllowThreads();
28495 (arg1)->Refresh(arg2,(wxRect const *)arg3);
28496
28497 wxPyEndAllowThreads(__tstate);
28498 if (PyErr_Occurred()) SWIG_fail;
28499 }
28500 Py_INCREF(Py_None); resultobj = Py_None;
28501 return resultobj;
28502 fail:
28503 return NULL;
28504 }
28505
28506
28507 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
28508 PyObject *resultobj;
28509 wxWindow *arg1 = (wxWindow *) 0 ;
28510 wxRect *arg2 = 0 ;
28511 wxRect temp2 ;
28512 PyObject * obj0 = 0 ;
28513 PyObject * obj1 = 0 ;
28514 char *kwnames[] = {
28515 (char *) "self",(char *) "rect", NULL
28516 };
28517
28518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RefreshRect",kwnames,&obj0,&obj1)) goto fail;
28519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28520 if (SWIG_arg_fail(1)) SWIG_fail;
28521 {
28522 arg2 = &temp2;
28523 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28524 }
28525 {
28526 PyThreadState* __tstate = wxPyBeginAllowThreads();
28527 (arg1)->RefreshRect((wxRect const &)*arg2);
28528
28529 wxPyEndAllowThreads(__tstate);
28530 if (PyErr_Occurred()) SWIG_fail;
28531 }
28532 Py_INCREF(Py_None); resultobj = Py_None;
28533 return resultobj;
28534 fail:
28535 return NULL;
28536 }
28537
28538
28539 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
28540 PyObject *resultobj;
28541 wxWindow *arg1 = (wxWindow *) 0 ;
28542 PyObject * obj0 = 0 ;
28543 char *kwnames[] = {
28544 (char *) "self", NULL
28545 };
28546
28547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
28548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28549 if (SWIG_arg_fail(1)) SWIG_fail;
28550 {
28551 PyThreadState* __tstate = wxPyBeginAllowThreads();
28552 (arg1)->Update();
28553
28554 wxPyEndAllowThreads(__tstate);
28555 if (PyErr_Occurred()) SWIG_fail;
28556 }
28557 Py_INCREF(Py_None); resultobj = Py_None;
28558 return resultobj;
28559 fail:
28560 return NULL;
28561 }
28562
28563
28564 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
28565 PyObject *resultobj;
28566 wxWindow *arg1 = (wxWindow *) 0 ;
28567 PyObject * obj0 = 0 ;
28568 char *kwnames[] = {
28569 (char *) "self", NULL
28570 };
28571
28572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
28573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28574 if (SWIG_arg_fail(1)) SWIG_fail;
28575 {
28576 PyThreadState* __tstate = wxPyBeginAllowThreads();
28577 (arg1)->ClearBackground();
28578
28579 wxPyEndAllowThreads(__tstate);
28580 if (PyErr_Occurred()) SWIG_fail;
28581 }
28582 Py_INCREF(Py_None); resultobj = Py_None;
28583 return resultobj;
28584 fail:
28585 return NULL;
28586 }
28587
28588
28589 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
28590 PyObject *resultobj;
28591 wxWindow *arg1 = (wxWindow *) 0 ;
28592 PyObject * obj0 = 0 ;
28593 char *kwnames[] = {
28594 (char *) "self", NULL
28595 };
28596
28597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
28598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28599 if (SWIG_arg_fail(1)) SWIG_fail;
28600 {
28601 PyThreadState* __tstate = wxPyBeginAllowThreads();
28602 (arg1)->Freeze();
28603
28604 wxPyEndAllowThreads(__tstate);
28605 if (PyErr_Occurred()) SWIG_fail;
28606 }
28607 Py_INCREF(Py_None); resultobj = Py_None;
28608 return resultobj;
28609 fail:
28610 return NULL;
28611 }
28612
28613
28614 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
28615 PyObject *resultobj;
28616 wxWindow *arg1 = (wxWindow *) 0 ;
28617 PyObject * obj0 = 0 ;
28618 char *kwnames[] = {
28619 (char *) "self", NULL
28620 };
28621
28622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
28623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28624 if (SWIG_arg_fail(1)) SWIG_fail;
28625 {
28626 PyThreadState* __tstate = wxPyBeginAllowThreads();
28627 (arg1)->Thaw();
28628
28629 wxPyEndAllowThreads(__tstate);
28630 if (PyErr_Occurred()) SWIG_fail;
28631 }
28632 Py_INCREF(Py_None); resultobj = Py_None;
28633 return resultobj;
28634 fail:
28635 return NULL;
28636 }
28637
28638
28639 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
28640 PyObject *resultobj;
28641 wxWindow *arg1 = (wxWindow *) 0 ;
28642 wxDC *arg2 = 0 ;
28643 PyObject * obj0 = 0 ;
28644 PyObject * obj1 = 0 ;
28645 char *kwnames[] = {
28646 (char *) "self",(char *) "dc", NULL
28647 };
28648
28649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
28650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28651 if (SWIG_arg_fail(1)) SWIG_fail;
28652 {
28653 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
28654 if (SWIG_arg_fail(2)) SWIG_fail;
28655 if (arg2 == NULL) {
28656 SWIG_null_ref("wxDC");
28657 }
28658 if (SWIG_arg_fail(2)) SWIG_fail;
28659 }
28660 {
28661 PyThreadState* __tstate = wxPyBeginAllowThreads();
28662 (arg1)->PrepareDC(*arg2);
28663
28664 wxPyEndAllowThreads(__tstate);
28665 if (PyErr_Occurred()) SWIG_fail;
28666 }
28667 Py_INCREF(Py_None); resultobj = Py_None;
28668 return resultobj;
28669 fail:
28670 return NULL;
28671 }
28672
28673
28674 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
28675 PyObject *resultobj;
28676 wxWindow *arg1 = (wxWindow *) 0 ;
28677 wxRegion *result;
28678 PyObject * obj0 = 0 ;
28679 char *kwnames[] = {
28680 (char *) "self", NULL
28681 };
28682
28683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
28684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28685 if (SWIG_arg_fail(1)) SWIG_fail;
28686 {
28687 PyThreadState* __tstate = wxPyBeginAllowThreads();
28688 {
28689 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
28690 result = (wxRegion *) &_result_ref;
28691 }
28692
28693 wxPyEndAllowThreads(__tstate);
28694 if (PyErr_Occurred()) SWIG_fail;
28695 }
28696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
28697 return resultobj;
28698 fail:
28699 return NULL;
28700 }
28701
28702
28703 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
28704 PyObject *resultobj;
28705 wxWindow *arg1 = (wxWindow *) 0 ;
28706 wxRect result;
28707 PyObject * obj0 = 0 ;
28708 char *kwnames[] = {
28709 (char *) "self", NULL
28710 };
28711
28712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
28713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28714 if (SWIG_arg_fail(1)) SWIG_fail;
28715 {
28716 PyThreadState* __tstate = wxPyBeginAllowThreads();
28717 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
28718
28719 wxPyEndAllowThreads(__tstate);
28720 if (PyErr_Occurred()) SWIG_fail;
28721 }
28722 {
28723 wxRect * resultptr;
28724 resultptr = new wxRect((wxRect &)(result));
28725 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
28726 }
28727 return resultobj;
28728 fail:
28729 return NULL;
28730 }
28731
28732
28733 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
28734 PyObject *resultobj;
28735 wxWindow *arg1 = (wxWindow *) 0 ;
28736 int arg2 ;
28737 int arg3 ;
28738 int arg4 = (int) 1 ;
28739 int arg5 = (int) 1 ;
28740 bool result;
28741 PyObject * obj0 = 0 ;
28742 PyObject * obj1 = 0 ;
28743 PyObject * obj2 = 0 ;
28744 PyObject * obj3 = 0 ;
28745 PyObject * obj4 = 0 ;
28746 char *kwnames[] = {
28747 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
28748 };
28749
28750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
28751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28752 if (SWIG_arg_fail(1)) SWIG_fail;
28753 {
28754 arg2 = (int)(SWIG_As_int(obj1));
28755 if (SWIG_arg_fail(2)) SWIG_fail;
28756 }
28757 {
28758 arg3 = (int)(SWIG_As_int(obj2));
28759 if (SWIG_arg_fail(3)) SWIG_fail;
28760 }
28761 if (obj3) {
28762 {
28763 arg4 = (int)(SWIG_As_int(obj3));
28764 if (SWIG_arg_fail(4)) SWIG_fail;
28765 }
28766 }
28767 if (obj4) {
28768 {
28769 arg5 = (int)(SWIG_As_int(obj4));
28770 if (SWIG_arg_fail(5)) SWIG_fail;
28771 }
28772 }
28773 {
28774 PyThreadState* __tstate = wxPyBeginAllowThreads();
28775 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
28776
28777 wxPyEndAllowThreads(__tstate);
28778 if (PyErr_Occurred()) SWIG_fail;
28779 }
28780 {
28781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28782 }
28783 return resultobj;
28784 fail:
28785 return NULL;
28786 }
28787
28788
28789 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
28790 PyObject *resultobj;
28791 wxWindow *arg1 = (wxWindow *) 0 ;
28792 wxPoint *arg2 = 0 ;
28793 bool result;
28794 wxPoint temp2 ;
28795 PyObject * obj0 = 0 ;
28796 PyObject * obj1 = 0 ;
28797 char *kwnames[] = {
28798 (char *) "self",(char *) "pt", NULL
28799 };
28800
28801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
28802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28803 if (SWIG_arg_fail(1)) SWIG_fail;
28804 {
28805 arg2 = &temp2;
28806 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28807 }
28808 {
28809 PyThreadState* __tstate = wxPyBeginAllowThreads();
28810 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
28811
28812 wxPyEndAllowThreads(__tstate);
28813 if (PyErr_Occurred()) SWIG_fail;
28814 }
28815 {
28816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28817 }
28818 return resultobj;
28819 fail:
28820 return NULL;
28821 }
28822
28823
28824 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
28825 PyObject *resultobj;
28826 wxWindow *arg1 = (wxWindow *) 0 ;
28827 wxRect *arg2 = 0 ;
28828 bool result;
28829 wxRect temp2 ;
28830 PyObject * obj0 = 0 ;
28831 PyObject * obj1 = 0 ;
28832 char *kwnames[] = {
28833 (char *) "self",(char *) "rect", NULL
28834 };
28835
28836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
28837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28838 if (SWIG_arg_fail(1)) SWIG_fail;
28839 {
28840 arg2 = &temp2;
28841 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28842 }
28843 {
28844 PyThreadState* __tstate = wxPyBeginAllowThreads();
28845 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
28846
28847 wxPyEndAllowThreads(__tstate);
28848 if (PyErr_Occurred()) SWIG_fail;
28849 }
28850 {
28851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28852 }
28853 return resultobj;
28854 fail:
28855 return NULL;
28856 }
28857
28858
28859 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
28860 PyObject *resultobj;
28861 wxWindow *arg1 = (wxWindow *) 0 ;
28862 wxVisualAttributes result;
28863 PyObject * obj0 = 0 ;
28864 char *kwnames[] = {
28865 (char *) "self", NULL
28866 };
28867
28868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
28869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28870 if (SWIG_arg_fail(1)) SWIG_fail;
28871 {
28872 PyThreadState* __tstate = wxPyBeginAllowThreads();
28873 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
28874
28875 wxPyEndAllowThreads(__tstate);
28876 if (PyErr_Occurred()) SWIG_fail;
28877 }
28878 {
28879 wxVisualAttributes * resultptr;
28880 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
28881 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
28882 }
28883 return resultobj;
28884 fail:
28885 return NULL;
28886 }
28887
28888
28889 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
28890 PyObject *resultobj;
28891 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
28892 wxVisualAttributes result;
28893 PyObject * obj0 = 0 ;
28894 char *kwnames[] = {
28895 (char *) "variant", NULL
28896 };
28897
28898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
28899 if (obj0) {
28900 {
28901 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
28902 if (SWIG_arg_fail(1)) SWIG_fail;
28903 }
28904 }
28905 {
28906 if (!wxPyCheckForApp()) SWIG_fail;
28907 PyThreadState* __tstate = wxPyBeginAllowThreads();
28908 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
28909
28910 wxPyEndAllowThreads(__tstate);
28911 if (PyErr_Occurred()) SWIG_fail;
28912 }
28913 {
28914 wxVisualAttributes * resultptr;
28915 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
28916 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
28917 }
28918 return resultobj;
28919 fail:
28920 return NULL;
28921 }
28922
28923
28924 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28925 PyObject *resultobj;
28926 wxWindow *arg1 = (wxWindow *) 0 ;
28927 wxColour *arg2 = 0 ;
28928 bool result;
28929 wxColour temp2 ;
28930 PyObject * obj0 = 0 ;
28931 PyObject * obj1 = 0 ;
28932 char *kwnames[] = {
28933 (char *) "self",(char *) "colour", NULL
28934 };
28935
28936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
28937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28938 if (SWIG_arg_fail(1)) SWIG_fail;
28939 {
28940 arg2 = &temp2;
28941 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
28942 }
28943 {
28944 PyThreadState* __tstate = wxPyBeginAllowThreads();
28945 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
28946
28947 wxPyEndAllowThreads(__tstate);
28948 if (PyErr_Occurred()) SWIG_fail;
28949 }
28950 {
28951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28952 }
28953 return resultobj;
28954 fail:
28955 return NULL;
28956 }
28957
28958
28959 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28960 PyObject *resultobj;
28961 wxWindow *arg1 = (wxWindow *) 0 ;
28962 wxColour *arg2 = 0 ;
28963 wxColour temp2 ;
28964 PyObject * obj0 = 0 ;
28965 PyObject * obj1 = 0 ;
28966 char *kwnames[] = {
28967 (char *) "self",(char *) "colour", NULL
28968 };
28969
28970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
28971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28972 if (SWIG_arg_fail(1)) SWIG_fail;
28973 {
28974 arg2 = &temp2;
28975 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
28976 }
28977 {
28978 PyThreadState* __tstate = wxPyBeginAllowThreads();
28979 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
28980
28981 wxPyEndAllowThreads(__tstate);
28982 if (PyErr_Occurred()) SWIG_fail;
28983 }
28984 Py_INCREF(Py_None); resultobj = Py_None;
28985 return resultobj;
28986 fail:
28987 return NULL;
28988 }
28989
28990
28991 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28992 PyObject *resultobj;
28993 wxWindow *arg1 = (wxWindow *) 0 ;
28994 wxColour *arg2 = 0 ;
28995 bool result;
28996 wxColour temp2 ;
28997 PyObject * obj0 = 0 ;
28998 PyObject * obj1 = 0 ;
28999 char *kwnames[] = {
29000 (char *) "self",(char *) "colour", NULL
29001 };
29002
29003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29005 if (SWIG_arg_fail(1)) SWIG_fail;
29006 {
29007 arg2 = &temp2;
29008 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29009 }
29010 {
29011 PyThreadState* __tstate = wxPyBeginAllowThreads();
29012 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29013
29014 wxPyEndAllowThreads(__tstate);
29015 if (PyErr_Occurred()) SWIG_fail;
29016 }
29017 {
29018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29019 }
29020 return resultobj;
29021 fail:
29022 return NULL;
29023 }
29024
29025
29026 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29027 PyObject *resultobj;
29028 wxWindow *arg1 = (wxWindow *) 0 ;
29029 wxColour *arg2 = 0 ;
29030 wxColour temp2 ;
29031 PyObject * obj0 = 0 ;
29032 PyObject * obj1 = 0 ;
29033 char *kwnames[] = {
29034 (char *) "self",(char *) "colour", NULL
29035 };
29036
29037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29039 if (SWIG_arg_fail(1)) SWIG_fail;
29040 {
29041 arg2 = &temp2;
29042 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29043 }
29044 {
29045 PyThreadState* __tstate = wxPyBeginAllowThreads();
29046 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29047
29048 wxPyEndAllowThreads(__tstate);
29049 if (PyErr_Occurred()) SWIG_fail;
29050 }
29051 Py_INCREF(Py_None); resultobj = Py_None;
29052 return resultobj;
29053 fail:
29054 return NULL;
29055 }
29056
29057
29058 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29059 PyObject *resultobj;
29060 wxWindow *arg1 = (wxWindow *) 0 ;
29061 wxColour result;
29062 PyObject * obj0 = 0 ;
29063 char *kwnames[] = {
29064 (char *) "self", NULL
29065 };
29066
29067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29069 if (SWIG_arg_fail(1)) SWIG_fail;
29070 {
29071 PyThreadState* __tstate = wxPyBeginAllowThreads();
29072 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29073
29074 wxPyEndAllowThreads(__tstate);
29075 if (PyErr_Occurred()) SWIG_fail;
29076 }
29077 {
29078 wxColour * resultptr;
29079 resultptr = new wxColour((wxColour &)(result));
29080 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29081 }
29082 return resultobj;
29083 fail:
29084 return NULL;
29085 }
29086
29087
29088 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29089 PyObject *resultobj;
29090 wxWindow *arg1 = (wxWindow *) 0 ;
29091 wxColour result;
29092 PyObject * obj0 = 0 ;
29093 char *kwnames[] = {
29094 (char *) "self", NULL
29095 };
29096
29097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29099 if (SWIG_arg_fail(1)) SWIG_fail;
29100 {
29101 PyThreadState* __tstate = wxPyBeginAllowThreads();
29102 result = ((wxWindow const *)arg1)->GetForegroundColour();
29103
29104 wxPyEndAllowThreads(__tstate);
29105 if (PyErr_Occurred()) SWIG_fail;
29106 }
29107 {
29108 wxColour * resultptr;
29109 resultptr = new wxColour((wxColour &)(result));
29110 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29111 }
29112 return resultobj;
29113 fail:
29114 return NULL;
29115 }
29116
29117
29118 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29119 PyObject *resultobj;
29120 wxWindow *arg1 = (wxWindow *) 0 ;
29121 wxBackgroundStyle arg2 ;
29122 bool result;
29123 PyObject * obj0 = 0 ;
29124 PyObject * obj1 = 0 ;
29125 char *kwnames[] = {
29126 (char *) "self",(char *) "style", NULL
29127 };
29128
29129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29131 if (SWIG_arg_fail(1)) SWIG_fail;
29132 {
29133 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29134 if (SWIG_arg_fail(2)) SWIG_fail;
29135 }
29136 {
29137 PyThreadState* __tstate = wxPyBeginAllowThreads();
29138 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29139
29140 wxPyEndAllowThreads(__tstate);
29141 if (PyErr_Occurred()) SWIG_fail;
29142 }
29143 {
29144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29145 }
29146 return resultobj;
29147 fail:
29148 return NULL;
29149 }
29150
29151
29152 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29153 PyObject *resultobj;
29154 wxWindow *arg1 = (wxWindow *) 0 ;
29155 wxBackgroundStyle result;
29156 PyObject * obj0 = 0 ;
29157 char *kwnames[] = {
29158 (char *) "self", NULL
29159 };
29160
29161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29163 if (SWIG_arg_fail(1)) SWIG_fail;
29164 {
29165 PyThreadState* __tstate = wxPyBeginAllowThreads();
29166 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29167
29168 wxPyEndAllowThreads(__tstate);
29169 if (PyErr_Occurred()) SWIG_fail;
29170 }
29171 resultobj = SWIG_From_int((result));
29172 return resultobj;
29173 fail:
29174 return NULL;
29175 }
29176
29177
29178 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29179 PyObject *resultobj;
29180 wxWindow *arg1 = (wxWindow *) 0 ;
29181 wxCursor *arg2 = 0 ;
29182 bool result;
29183 PyObject * obj0 = 0 ;
29184 PyObject * obj1 = 0 ;
29185 char *kwnames[] = {
29186 (char *) "self",(char *) "cursor", NULL
29187 };
29188
29189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29191 if (SWIG_arg_fail(1)) SWIG_fail;
29192 {
29193 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29194 if (SWIG_arg_fail(2)) SWIG_fail;
29195 if (arg2 == NULL) {
29196 SWIG_null_ref("wxCursor");
29197 }
29198 if (SWIG_arg_fail(2)) SWIG_fail;
29199 }
29200 {
29201 PyThreadState* __tstate = wxPyBeginAllowThreads();
29202 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29203
29204 wxPyEndAllowThreads(__tstate);
29205 if (PyErr_Occurred()) SWIG_fail;
29206 }
29207 {
29208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29209 }
29210 return resultobj;
29211 fail:
29212 return NULL;
29213 }
29214
29215
29216 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29217 PyObject *resultobj;
29218 wxWindow *arg1 = (wxWindow *) 0 ;
29219 wxCursor result;
29220 PyObject * obj0 = 0 ;
29221 char *kwnames[] = {
29222 (char *) "self", NULL
29223 };
29224
29225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29227 if (SWIG_arg_fail(1)) SWIG_fail;
29228 {
29229 PyThreadState* __tstate = wxPyBeginAllowThreads();
29230 result = (arg1)->GetCursor();
29231
29232 wxPyEndAllowThreads(__tstate);
29233 if (PyErr_Occurred()) SWIG_fail;
29234 }
29235 {
29236 wxCursor * resultptr;
29237 resultptr = new wxCursor((wxCursor &)(result));
29238 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29239 }
29240 return resultobj;
29241 fail:
29242 return NULL;
29243 }
29244
29245
29246 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29247 PyObject *resultobj;
29248 wxWindow *arg1 = (wxWindow *) 0 ;
29249 wxFont *arg2 = 0 ;
29250 bool result;
29251 PyObject * obj0 = 0 ;
29252 PyObject * obj1 = 0 ;
29253 char *kwnames[] = {
29254 (char *) "self",(char *) "font", NULL
29255 };
29256
29257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29259 if (SWIG_arg_fail(1)) SWIG_fail;
29260 {
29261 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29262 if (SWIG_arg_fail(2)) SWIG_fail;
29263 if (arg2 == NULL) {
29264 SWIG_null_ref("wxFont");
29265 }
29266 if (SWIG_arg_fail(2)) SWIG_fail;
29267 }
29268 {
29269 PyThreadState* __tstate = wxPyBeginAllowThreads();
29270 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29271
29272 wxPyEndAllowThreads(__tstate);
29273 if (PyErr_Occurred()) SWIG_fail;
29274 }
29275 {
29276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29277 }
29278 return resultobj;
29279 fail:
29280 return NULL;
29281 }
29282
29283
29284 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29285 PyObject *resultobj;
29286 wxWindow *arg1 = (wxWindow *) 0 ;
29287 wxFont *arg2 = 0 ;
29288 PyObject * obj0 = 0 ;
29289 PyObject * obj1 = 0 ;
29290 char *kwnames[] = {
29291 (char *) "self",(char *) "font", NULL
29292 };
29293
29294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29296 if (SWIG_arg_fail(1)) SWIG_fail;
29297 {
29298 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29299 if (SWIG_arg_fail(2)) SWIG_fail;
29300 if (arg2 == NULL) {
29301 SWIG_null_ref("wxFont");
29302 }
29303 if (SWIG_arg_fail(2)) SWIG_fail;
29304 }
29305 {
29306 PyThreadState* __tstate = wxPyBeginAllowThreads();
29307 (arg1)->SetOwnFont((wxFont const &)*arg2);
29308
29309 wxPyEndAllowThreads(__tstate);
29310 if (PyErr_Occurred()) SWIG_fail;
29311 }
29312 Py_INCREF(Py_None); resultobj = Py_None;
29313 return resultobj;
29314 fail:
29315 return NULL;
29316 }
29317
29318
29319 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29320 PyObject *resultobj;
29321 wxWindow *arg1 = (wxWindow *) 0 ;
29322 wxFont result;
29323 PyObject * obj0 = 0 ;
29324 char *kwnames[] = {
29325 (char *) "self", NULL
29326 };
29327
29328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29330 if (SWIG_arg_fail(1)) SWIG_fail;
29331 {
29332 PyThreadState* __tstate = wxPyBeginAllowThreads();
29333 result = (arg1)->GetFont();
29334
29335 wxPyEndAllowThreads(__tstate);
29336 if (PyErr_Occurred()) SWIG_fail;
29337 }
29338 {
29339 wxFont * resultptr;
29340 resultptr = new wxFont((wxFont &)(result));
29341 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29342 }
29343 return resultobj;
29344 fail:
29345 return NULL;
29346 }
29347
29348
29349 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29350 PyObject *resultobj;
29351 wxWindow *arg1 = (wxWindow *) 0 ;
29352 wxCaret *arg2 = (wxCaret *) 0 ;
29353 PyObject * obj0 = 0 ;
29354 PyObject * obj1 = 0 ;
29355 char *kwnames[] = {
29356 (char *) "self",(char *) "caret", NULL
29357 };
29358
29359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
29360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29361 if (SWIG_arg_fail(1)) SWIG_fail;
29362 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
29363 if (SWIG_arg_fail(2)) SWIG_fail;
29364 {
29365 PyThreadState* __tstate = wxPyBeginAllowThreads();
29366 (arg1)->SetCaret(arg2);
29367
29368 wxPyEndAllowThreads(__tstate);
29369 if (PyErr_Occurred()) SWIG_fail;
29370 }
29371 Py_INCREF(Py_None); resultobj = Py_None;
29372 return resultobj;
29373 fail:
29374 return NULL;
29375 }
29376
29377
29378 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29379 PyObject *resultobj;
29380 wxWindow *arg1 = (wxWindow *) 0 ;
29381 wxCaret *result;
29382 PyObject * obj0 = 0 ;
29383 char *kwnames[] = {
29384 (char *) "self", NULL
29385 };
29386
29387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
29388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29389 if (SWIG_arg_fail(1)) SWIG_fail;
29390 {
29391 PyThreadState* __tstate = wxPyBeginAllowThreads();
29392 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
29393
29394 wxPyEndAllowThreads(__tstate);
29395 if (PyErr_Occurred()) SWIG_fail;
29396 }
29397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
29398 return resultobj;
29399 fail:
29400 return NULL;
29401 }
29402
29403
29404 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29405 PyObject *resultobj;
29406 wxWindow *arg1 = (wxWindow *) 0 ;
29407 int result;
29408 PyObject * obj0 = 0 ;
29409 char *kwnames[] = {
29410 (char *) "self", NULL
29411 };
29412
29413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
29414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29415 if (SWIG_arg_fail(1)) SWIG_fail;
29416 {
29417 PyThreadState* __tstate = wxPyBeginAllowThreads();
29418 result = (int)((wxWindow const *)arg1)->GetCharHeight();
29419
29420 wxPyEndAllowThreads(__tstate);
29421 if (PyErr_Occurred()) SWIG_fail;
29422 }
29423 {
29424 resultobj = SWIG_From_int((int)(result));
29425 }
29426 return resultobj;
29427 fail:
29428 return NULL;
29429 }
29430
29431
29432 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29433 PyObject *resultobj;
29434 wxWindow *arg1 = (wxWindow *) 0 ;
29435 int result;
29436 PyObject * obj0 = 0 ;
29437 char *kwnames[] = {
29438 (char *) "self", NULL
29439 };
29440
29441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
29442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29443 if (SWIG_arg_fail(1)) SWIG_fail;
29444 {
29445 PyThreadState* __tstate = wxPyBeginAllowThreads();
29446 result = (int)((wxWindow const *)arg1)->GetCharWidth();
29447
29448 wxPyEndAllowThreads(__tstate);
29449 if (PyErr_Occurred()) SWIG_fail;
29450 }
29451 {
29452 resultobj = SWIG_From_int((int)(result));
29453 }
29454 return resultobj;
29455 fail:
29456 return NULL;
29457 }
29458
29459
29460 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29461 PyObject *resultobj;
29462 wxWindow *arg1 = (wxWindow *) 0 ;
29463 wxString *arg2 = 0 ;
29464 int *arg3 = (int *) 0 ;
29465 int *arg4 = (int *) 0 ;
29466 bool temp2 = false ;
29467 int temp3 ;
29468 int res3 = 0 ;
29469 int temp4 ;
29470 int res4 = 0 ;
29471 PyObject * obj0 = 0 ;
29472 PyObject * obj1 = 0 ;
29473 char *kwnames[] = {
29474 (char *) "self",(char *) "string", NULL
29475 };
29476
29477 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29478 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
29480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29481 if (SWIG_arg_fail(1)) SWIG_fail;
29482 {
29483 arg2 = wxString_in_helper(obj1);
29484 if (arg2 == NULL) SWIG_fail;
29485 temp2 = true;
29486 }
29487 {
29488 PyThreadState* __tstate = wxPyBeginAllowThreads();
29489 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
29490
29491 wxPyEndAllowThreads(__tstate);
29492 if (PyErr_Occurred()) SWIG_fail;
29493 }
29494 Py_INCREF(Py_None); resultobj = Py_None;
29495 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29496 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29497 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29498 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29499 {
29500 if (temp2)
29501 delete arg2;
29502 }
29503 return resultobj;
29504 fail:
29505 {
29506 if (temp2)
29507 delete arg2;
29508 }
29509 return NULL;
29510 }
29511
29512
29513 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29514 PyObject *resultobj;
29515 wxWindow *arg1 = (wxWindow *) 0 ;
29516 wxString *arg2 = 0 ;
29517 int *arg3 = (int *) 0 ;
29518 int *arg4 = (int *) 0 ;
29519 int *arg5 = (int *) 0 ;
29520 int *arg6 = (int *) 0 ;
29521 wxFont *arg7 = (wxFont *) NULL ;
29522 bool temp2 = false ;
29523 int temp3 ;
29524 int res3 = 0 ;
29525 int temp4 ;
29526 int res4 = 0 ;
29527 int temp5 ;
29528 int res5 = 0 ;
29529 int temp6 ;
29530 int res6 = 0 ;
29531 PyObject * obj0 = 0 ;
29532 PyObject * obj1 = 0 ;
29533 PyObject * obj2 = 0 ;
29534 char *kwnames[] = {
29535 (char *) "self",(char *) "string",(char *) "font", NULL
29536 };
29537
29538 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29539 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29540 arg5 = &temp5; res5 = SWIG_NEWOBJ;
29541 arg6 = &temp6; res6 = SWIG_NEWOBJ;
29542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
29543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29544 if (SWIG_arg_fail(1)) SWIG_fail;
29545 {
29546 arg2 = wxString_in_helper(obj1);
29547 if (arg2 == NULL) SWIG_fail;
29548 temp2 = true;
29549 }
29550 if (obj2) {
29551 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29552 if (SWIG_arg_fail(7)) SWIG_fail;
29553 }
29554 {
29555 PyThreadState* __tstate = wxPyBeginAllowThreads();
29556 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
29557
29558 wxPyEndAllowThreads(__tstate);
29559 if (PyErr_Occurred()) SWIG_fail;
29560 }
29561 Py_INCREF(Py_None); resultobj = Py_None;
29562 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29563 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29564 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29565 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29566 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
29567 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
29568 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
29569 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
29570 {
29571 if (temp2)
29572 delete arg2;
29573 }
29574 return resultobj;
29575 fail:
29576 {
29577 if (temp2)
29578 delete arg2;
29579 }
29580 return NULL;
29581 }
29582
29583
29584 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
29585 PyObject *resultobj;
29586 wxWindow *arg1 = (wxWindow *) 0 ;
29587 int *arg2 = (int *) 0 ;
29588 int *arg3 = (int *) 0 ;
29589 int temp2 ;
29590 int res2 = 0 ;
29591 int temp3 ;
29592 int res3 = 0 ;
29593 PyObject * obj0 = 0 ;
29594 PyObject * obj1 = 0 ;
29595 PyObject * obj2 = 0 ;
29596 char *kwnames[] = {
29597 (char *) "self",(char *) "x",(char *) "y", NULL
29598 };
29599
29600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29602 if (SWIG_arg_fail(1)) SWIG_fail;
29603 {
29604 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29605 temp2 = SWIG_As_int(obj1);
29606 if (SWIG_arg_fail(2)) SWIG_fail;
29607 arg2 = &temp2;
29608 res2 = SWIG_NEWOBJ;
29609 }
29610 }
29611 {
29612 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29613 temp3 = SWIG_As_int(obj2);
29614 if (SWIG_arg_fail(3)) SWIG_fail;
29615 arg3 = &temp3;
29616 res3 = SWIG_NEWOBJ;
29617 }
29618 }
29619 {
29620 PyThreadState* __tstate = wxPyBeginAllowThreads();
29621 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
29622
29623 wxPyEndAllowThreads(__tstate);
29624 if (PyErr_Occurred()) SWIG_fail;
29625 }
29626 Py_INCREF(Py_None); resultobj = Py_None;
29627 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29628 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29629 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29630 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29631 return resultobj;
29632 fail:
29633 return NULL;
29634 }
29635
29636
29637 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
29638 PyObject *resultobj;
29639 wxWindow *arg1 = (wxWindow *) 0 ;
29640 int *arg2 = (int *) 0 ;
29641 int *arg3 = (int *) 0 ;
29642 int temp2 ;
29643 int res2 = 0 ;
29644 int temp3 ;
29645 int res3 = 0 ;
29646 PyObject * obj0 = 0 ;
29647 PyObject * obj1 = 0 ;
29648 PyObject * obj2 = 0 ;
29649 char *kwnames[] = {
29650 (char *) "self",(char *) "x",(char *) "y", NULL
29651 };
29652
29653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29655 if (SWIG_arg_fail(1)) SWIG_fail;
29656 {
29657 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29658 temp2 = SWIG_As_int(obj1);
29659 if (SWIG_arg_fail(2)) SWIG_fail;
29660 arg2 = &temp2;
29661 res2 = SWIG_NEWOBJ;
29662 }
29663 }
29664 {
29665 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29666 temp3 = SWIG_As_int(obj2);
29667 if (SWIG_arg_fail(3)) SWIG_fail;
29668 arg3 = &temp3;
29669 res3 = SWIG_NEWOBJ;
29670 }
29671 }
29672 {
29673 PyThreadState* __tstate = wxPyBeginAllowThreads();
29674 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
29675
29676 wxPyEndAllowThreads(__tstate);
29677 if (PyErr_Occurred()) SWIG_fail;
29678 }
29679 Py_INCREF(Py_None); resultobj = Py_None;
29680 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29681 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29682 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29683 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29684 return resultobj;
29685 fail:
29686 return NULL;
29687 }
29688
29689
29690 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
29691 PyObject *resultobj;
29692 wxWindow *arg1 = (wxWindow *) 0 ;
29693 wxPoint *arg2 = 0 ;
29694 wxPoint result;
29695 wxPoint temp2 ;
29696 PyObject * obj0 = 0 ;
29697 PyObject * obj1 = 0 ;
29698 char *kwnames[] = {
29699 (char *) "self",(char *) "pt", NULL
29700 };
29701
29702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
29703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29704 if (SWIG_arg_fail(1)) SWIG_fail;
29705 {
29706 arg2 = &temp2;
29707 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29708 }
29709 {
29710 PyThreadState* __tstate = wxPyBeginAllowThreads();
29711 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
29712
29713 wxPyEndAllowThreads(__tstate);
29714 if (PyErr_Occurred()) SWIG_fail;
29715 }
29716 {
29717 wxPoint * resultptr;
29718 resultptr = new wxPoint((wxPoint &)(result));
29719 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29720 }
29721 return resultobj;
29722 fail:
29723 return NULL;
29724 }
29725
29726
29727 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
29728 PyObject *resultobj;
29729 wxWindow *arg1 = (wxWindow *) 0 ;
29730 wxPoint *arg2 = 0 ;
29731 wxPoint result;
29732 wxPoint temp2 ;
29733 PyObject * obj0 = 0 ;
29734 PyObject * obj1 = 0 ;
29735 char *kwnames[] = {
29736 (char *) "self",(char *) "pt", NULL
29737 };
29738
29739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
29740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29741 if (SWIG_arg_fail(1)) SWIG_fail;
29742 {
29743 arg2 = &temp2;
29744 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29745 }
29746 {
29747 PyThreadState* __tstate = wxPyBeginAllowThreads();
29748 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
29749
29750 wxPyEndAllowThreads(__tstate);
29751 if (PyErr_Occurred()) SWIG_fail;
29752 }
29753 {
29754 wxPoint * resultptr;
29755 resultptr = new wxPoint((wxPoint &)(result));
29756 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29757 }
29758 return resultobj;
29759 fail:
29760 return NULL;
29761 }
29762
29763
29764 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
29765 PyObject *resultobj;
29766 wxWindow *arg1 = (wxWindow *) 0 ;
29767 int arg2 ;
29768 int arg3 ;
29769 wxHitTest result;
29770 PyObject * obj0 = 0 ;
29771 PyObject * obj1 = 0 ;
29772 PyObject * obj2 = 0 ;
29773 char *kwnames[] = {
29774 (char *) "self",(char *) "x",(char *) "y", NULL
29775 };
29776
29777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29779 if (SWIG_arg_fail(1)) SWIG_fail;
29780 {
29781 arg2 = (int)(SWIG_As_int(obj1));
29782 if (SWIG_arg_fail(2)) SWIG_fail;
29783 }
29784 {
29785 arg3 = (int)(SWIG_As_int(obj2));
29786 if (SWIG_arg_fail(3)) SWIG_fail;
29787 }
29788 {
29789 PyThreadState* __tstate = wxPyBeginAllowThreads();
29790 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
29791
29792 wxPyEndAllowThreads(__tstate);
29793 if (PyErr_Occurred()) SWIG_fail;
29794 }
29795 resultobj = SWIG_From_int((result));
29796 return resultobj;
29797 fail:
29798 return NULL;
29799 }
29800
29801
29802 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
29803 PyObject *resultobj;
29804 wxWindow *arg1 = (wxWindow *) 0 ;
29805 wxPoint *arg2 = 0 ;
29806 wxHitTest result;
29807 wxPoint temp2 ;
29808 PyObject * obj0 = 0 ;
29809 PyObject * obj1 = 0 ;
29810 char *kwnames[] = {
29811 (char *) "self",(char *) "pt", NULL
29812 };
29813
29814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
29815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29816 if (SWIG_arg_fail(1)) SWIG_fail;
29817 {
29818 arg2 = &temp2;
29819 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29820 }
29821 {
29822 PyThreadState* __tstate = wxPyBeginAllowThreads();
29823 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
29824
29825 wxPyEndAllowThreads(__tstate);
29826 if (PyErr_Occurred()) SWIG_fail;
29827 }
29828 resultobj = SWIG_From_int((result));
29829 return resultobj;
29830 fail:
29831 return NULL;
29832 }
29833
29834
29835 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
29836 PyObject *resultobj;
29837 wxWindow *arg1 = (wxWindow *) 0 ;
29838 long arg2 ;
29839 wxBorder result;
29840 PyObject * obj0 = 0 ;
29841 PyObject * obj1 = 0 ;
29842
29843 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
29844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29845 if (SWIG_arg_fail(1)) SWIG_fail;
29846 {
29847 arg2 = (long)(SWIG_As_long(obj1));
29848 if (SWIG_arg_fail(2)) SWIG_fail;
29849 }
29850 {
29851 PyThreadState* __tstate = wxPyBeginAllowThreads();
29852 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
29853
29854 wxPyEndAllowThreads(__tstate);
29855 if (PyErr_Occurred()) SWIG_fail;
29856 }
29857 resultobj = SWIG_From_int((result));
29858 return resultobj;
29859 fail:
29860 return NULL;
29861 }
29862
29863
29864 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
29865 PyObject *resultobj;
29866 wxWindow *arg1 = (wxWindow *) 0 ;
29867 wxBorder result;
29868 PyObject * obj0 = 0 ;
29869
29870 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
29871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29872 if (SWIG_arg_fail(1)) SWIG_fail;
29873 {
29874 PyThreadState* __tstate = wxPyBeginAllowThreads();
29875 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
29876
29877 wxPyEndAllowThreads(__tstate);
29878 if (PyErr_Occurred()) SWIG_fail;
29879 }
29880 resultobj = SWIG_From_int((result));
29881 return resultobj;
29882 fail:
29883 return NULL;
29884 }
29885
29886
29887 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
29888 int argc;
29889 PyObject *argv[3];
29890 int ii;
29891
29892 argc = PyObject_Length(args);
29893 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
29894 argv[ii] = PyTuple_GetItem(args,ii);
29895 }
29896 if (argc == 1) {
29897 int _v;
29898 {
29899 void *ptr;
29900 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
29901 _v = 0;
29902 PyErr_Clear();
29903 } else {
29904 _v = 1;
29905 }
29906 }
29907 if (_v) {
29908 return _wrap_Window_GetBorder__SWIG_1(self,args);
29909 }
29910 }
29911 if (argc == 2) {
29912 int _v;
29913 {
29914 void *ptr;
29915 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
29916 _v = 0;
29917 PyErr_Clear();
29918 } else {
29919 _v = 1;
29920 }
29921 }
29922 if (_v) {
29923 _v = SWIG_Check_long(argv[1]);
29924 if (_v) {
29925 return _wrap_Window_GetBorder__SWIG_0(self,args);
29926 }
29927 }
29928 }
29929
29930 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
29931 return NULL;
29932 }
29933
29934
29935 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
29936 PyObject *resultobj;
29937 wxWindow *arg1 = (wxWindow *) 0 ;
29938 long arg2 = (long) wxUPDATE_UI_NONE ;
29939 PyObject * obj0 = 0 ;
29940 PyObject * obj1 = 0 ;
29941 char *kwnames[] = {
29942 (char *) "self",(char *) "flags", NULL
29943 };
29944
29945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
29946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29947 if (SWIG_arg_fail(1)) SWIG_fail;
29948 if (obj1) {
29949 {
29950 arg2 = (long)(SWIG_As_long(obj1));
29951 if (SWIG_arg_fail(2)) SWIG_fail;
29952 }
29953 }
29954 {
29955 PyThreadState* __tstate = wxPyBeginAllowThreads();
29956 (arg1)->UpdateWindowUI(arg2);
29957
29958 wxPyEndAllowThreads(__tstate);
29959 if (PyErr_Occurred()) SWIG_fail;
29960 }
29961 Py_INCREF(Py_None); resultobj = Py_None;
29962 return resultobj;
29963 fail:
29964 return NULL;
29965 }
29966
29967
29968 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
29969 PyObject *resultobj;
29970 wxWindow *arg1 = (wxWindow *) 0 ;
29971 wxMenu *arg2 = (wxMenu *) 0 ;
29972 int arg3 = (int) -1 ;
29973 int arg4 = (int) -1 ;
29974 bool result;
29975 PyObject * obj0 = 0 ;
29976 PyObject * obj1 = 0 ;
29977 PyObject * obj2 = 0 ;
29978 PyObject * obj3 = 0 ;
29979 char *kwnames[] = {
29980 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
29981 };
29982
29983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29985 if (SWIG_arg_fail(1)) SWIG_fail;
29986 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
29987 if (SWIG_arg_fail(2)) SWIG_fail;
29988 if (obj2) {
29989 {
29990 arg3 = (int)(SWIG_As_int(obj2));
29991 if (SWIG_arg_fail(3)) SWIG_fail;
29992 }
29993 }
29994 if (obj3) {
29995 {
29996 arg4 = (int)(SWIG_As_int(obj3));
29997 if (SWIG_arg_fail(4)) SWIG_fail;
29998 }
29999 }
30000 {
30001 PyThreadState* __tstate = wxPyBeginAllowThreads();
30002 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30003
30004 wxPyEndAllowThreads(__tstate);
30005 if (PyErr_Occurred()) SWIG_fail;
30006 }
30007 {
30008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30009 }
30010 return resultobj;
30011 fail:
30012 return NULL;
30013 }
30014
30015
30016 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30017 PyObject *resultobj;
30018 wxWindow *arg1 = (wxWindow *) 0 ;
30019 wxMenu *arg2 = (wxMenu *) 0 ;
30020 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30021 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30022 bool result;
30023 wxPoint temp3 ;
30024 PyObject * obj0 = 0 ;
30025 PyObject * obj1 = 0 ;
30026 PyObject * obj2 = 0 ;
30027 char *kwnames[] = {
30028 (char *) "self",(char *) "menu",(char *) "pos", NULL
30029 };
30030
30031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30033 if (SWIG_arg_fail(1)) SWIG_fail;
30034 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30035 if (SWIG_arg_fail(2)) SWIG_fail;
30036 if (obj2) {
30037 {
30038 arg3 = &temp3;
30039 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30040 }
30041 }
30042 {
30043 PyThreadState* __tstate = wxPyBeginAllowThreads();
30044 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30045
30046 wxPyEndAllowThreads(__tstate);
30047 if (PyErr_Occurred()) SWIG_fail;
30048 }
30049 {
30050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30051 }
30052 return resultobj;
30053 fail:
30054 return NULL;
30055 }
30056
30057
30058 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30059 PyObject *resultobj;
30060 wxWindow *arg1 = (wxWindow *) 0 ;
30061 long result;
30062 PyObject * obj0 = 0 ;
30063 char *kwnames[] = {
30064 (char *) "self", NULL
30065 };
30066
30067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30069 if (SWIG_arg_fail(1)) SWIG_fail;
30070 {
30071 PyThreadState* __tstate = wxPyBeginAllowThreads();
30072 result = (long)wxWindow_GetHandle(arg1);
30073
30074 wxPyEndAllowThreads(__tstate);
30075 if (PyErr_Occurred()) SWIG_fail;
30076 }
30077 {
30078 resultobj = SWIG_From_long((long)(result));
30079 }
30080 return resultobj;
30081 fail:
30082 return NULL;
30083 }
30084
30085
30086 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30087 PyObject *resultobj;
30088 wxWindow *arg1 = (wxWindow *) 0 ;
30089 long arg2 ;
30090 PyObject * obj0 = 0 ;
30091 PyObject * obj1 = 0 ;
30092 char *kwnames[] = {
30093 (char *) "self",(char *) "handle", NULL
30094 };
30095
30096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30098 if (SWIG_arg_fail(1)) SWIG_fail;
30099 {
30100 arg2 = (long)(SWIG_As_long(obj1));
30101 if (SWIG_arg_fail(2)) SWIG_fail;
30102 }
30103 {
30104 PyThreadState* __tstate = wxPyBeginAllowThreads();
30105 wxWindow_AssociateHandle(arg1,arg2);
30106
30107 wxPyEndAllowThreads(__tstate);
30108 if (PyErr_Occurred()) SWIG_fail;
30109 }
30110 Py_INCREF(Py_None); resultobj = Py_None;
30111 return resultobj;
30112 fail:
30113 return NULL;
30114 }
30115
30116
30117 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30118 PyObject *resultobj;
30119 wxWindow *arg1 = (wxWindow *) 0 ;
30120 PyObject * obj0 = 0 ;
30121 char *kwnames[] = {
30122 (char *) "self", NULL
30123 };
30124
30125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30127 if (SWIG_arg_fail(1)) SWIG_fail;
30128 {
30129 PyThreadState* __tstate = wxPyBeginAllowThreads();
30130 (arg1)->DissociateHandle();
30131
30132 wxPyEndAllowThreads(__tstate);
30133 if (PyErr_Occurred()) SWIG_fail;
30134 }
30135 Py_INCREF(Py_None); resultobj = Py_None;
30136 return resultobj;
30137 fail:
30138 return NULL;
30139 }
30140
30141
30142 static PyObject *_wrap_Window_OnPaint(PyObject *, PyObject *args, PyObject *kwargs) {
30143 PyObject *resultobj;
30144 wxWindow *arg1 = (wxWindow *) 0 ;
30145 wxPaintEvent *arg2 = 0 ;
30146 PyObject * obj0 = 0 ;
30147 PyObject * obj1 = 0 ;
30148 char *kwnames[] = {
30149 (char *) "self",(char *) "event", NULL
30150 };
30151
30152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) goto fail;
30153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30154 if (SWIG_arg_fail(1)) SWIG_fail;
30155 {
30156 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_EXCEPTION | 0);
30157 if (SWIG_arg_fail(2)) SWIG_fail;
30158 if (arg2 == NULL) {
30159 SWIG_null_ref("wxPaintEvent");
30160 }
30161 if (SWIG_arg_fail(2)) SWIG_fail;
30162 }
30163 {
30164 PyThreadState* __tstate = wxPyBeginAllowThreads();
30165 (arg1)->OnPaint(*arg2);
30166
30167 wxPyEndAllowThreads(__tstate);
30168 if (PyErr_Occurred()) SWIG_fail;
30169 }
30170 Py_INCREF(Py_None); resultobj = Py_None;
30171 return resultobj;
30172 fail:
30173 return NULL;
30174 }
30175
30176
30177 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30178 PyObject *resultobj;
30179 wxWindow *arg1 = (wxWindow *) 0 ;
30180 int arg2 ;
30181 bool result;
30182 PyObject * obj0 = 0 ;
30183 PyObject * obj1 = 0 ;
30184 char *kwnames[] = {
30185 (char *) "self",(char *) "orient", NULL
30186 };
30187
30188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30190 if (SWIG_arg_fail(1)) SWIG_fail;
30191 {
30192 arg2 = (int)(SWIG_As_int(obj1));
30193 if (SWIG_arg_fail(2)) SWIG_fail;
30194 }
30195 {
30196 PyThreadState* __tstate = wxPyBeginAllowThreads();
30197 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30198
30199 wxPyEndAllowThreads(__tstate);
30200 if (PyErr_Occurred()) SWIG_fail;
30201 }
30202 {
30203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30204 }
30205 return resultobj;
30206 fail:
30207 return NULL;
30208 }
30209
30210
30211 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30212 PyObject *resultobj;
30213 wxWindow *arg1 = (wxWindow *) 0 ;
30214 int arg2 ;
30215 int arg3 ;
30216 int arg4 ;
30217 int arg5 ;
30218 bool arg6 = (bool) true ;
30219 PyObject * obj0 = 0 ;
30220 PyObject * obj1 = 0 ;
30221 PyObject * obj2 = 0 ;
30222 PyObject * obj3 = 0 ;
30223 PyObject * obj4 = 0 ;
30224 PyObject * obj5 = 0 ;
30225 char *kwnames[] = {
30226 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30227 };
30228
30229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30231 if (SWIG_arg_fail(1)) SWIG_fail;
30232 {
30233 arg2 = (int)(SWIG_As_int(obj1));
30234 if (SWIG_arg_fail(2)) SWIG_fail;
30235 }
30236 {
30237 arg3 = (int)(SWIG_As_int(obj2));
30238 if (SWIG_arg_fail(3)) SWIG_fail;
30239 }
30240 {
30241 arg4 = (int)(SWIG_As_int(obj3));
30242 if (SWIG_arg_fail(4)) SWIG_fail;
30243 }
30244 {
30245 arg5 = (int)(SWIG_As_int(obj4));
30246 if (SWIG_arg_fail(5)) SWIG_fail;
30247 }
30248 if (obj5) {
30249 {
30250 arg6 = (bool)(SWIG_As_bool(obj5));
30251 if (SWIG_arg_fail(6)) SWIG_fail;
30252 }
30253 }
30254 {
30255 PyThreadState* __tstate = wxPyBeginAllowThreads();
30256 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30257
30258 wxPyEndAllowThreads(__tstate);
30259 if (PyErr_Occurred()) SWIG_fail;
30260 }
30261 Py_INCREF(Py_None); resultobj = Py_None;
30262 return resultobj;
30263 fail:
30264 return NULL;
30265 }
30266
30267
30268 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30269 PyObject *resultobj;
30270 wxWindow *arg1 = (wxWindow *) 0 ;
30271 int arg2 ;
30272 int arg3 ;
30273 bool arg4 = (bool) true ;
30274 PyObject * obj0 = 0 ;
30275 PyObject * obj1 = 0 ;
30276 PyObject * obj2 = 0 ;
30277 PyObject * obj3 = 0 ;
30278 char *kwnames[] = {
30279 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30280 };
30281
30282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30284 if (SWIG_arg_fail(1)) SWIG_fail;
30285 {
30286 arg2 = (int)(SWIG_As_int(obj1));
30287 if (SWIG_arg_fail(2)) SWIG_fail;
30288 }
30289 {
30290 arg3 = (int)(SWIG_As_int(obj2));
30291 if (SWIG_arg_fail(3)) SWIG_fail;
30292 }
30293 if (obj3) {
30294 {
30295 arg4 = (bool)(SWIG_As_bool(obj3));
30296 if (SWIG_arg_fail(4)) SWIG_fail;
30297 }
30298 }
30299 {
30300 PyThreadState* __tstate = wxPyBeginAllowThreads();
30301 (arg1)->SetScrollPos(arg2,arg3,arg4);
30302
30303 wxPyEndAllowThreads(__tstate);
30304 if (PyErr_Occurred()) SWIG_fail;
30305 }
30306 Py_INCREF(Py_None); resultobj = Py_None;
30307 return resultobj;
30308 fail:
30309 return NULL;
30310 }
30311
30312
30313 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30314 PyObject *resultobj;
30315 wxWindow *arg1 = (wxWindow *) 0 ;
30316 int arg2 ;
30317 int result;
30318 PyObject * obj0 = 0 ;
30319 PyObject * obj1 = 0 ;
30320 char *kwnames[] = {
30321 (char *) "self",(char *) "orientation", NULL
30322 };
30323
30324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30326 if (SWIG_arg_fail(1)) SWIG_fail;
30327 {
30328 arg2 = (int)(SWIG_As_int(obj1));
30329 if (SWIG_arg_fail(2)) SWIG_fail;
30330 }
30331 {
30332 PyThreadState* __tstate = wxPyBeginAllowThreads();
30333 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30334
30335 wxPyEndAllowThreads(__tstate);
30336 if (PyErr_Occurred()) SWIG_fail;
30337 }
30338 {
30339 resultobj = SWIG_From_int((int)(result));
30340 }
30341 return resultobj;
30342 fail:
30343 return NULL;
30344 }
30345
30346
30347 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30348 PyObject *resultobj;
30349 wxWindow *arg1 = (wxWindow *) 0 ;
30350 int arg2 ;
30351 int result;
30352 PyObject * obj0 = 0 ;
30353 PyObject * obj1 = 0 ;
30354 char *kwnames[] = {
30355 (char *) "self",(char *) "orientation", NULL
30356 };
30357
30358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30360 if (SWIG_arg_fail(1)) SWIG_fail;
30361 {
30362 arg2 = (int)(SWIG_As_int(obj1));
30363 if (SWIG_arg_fail(2)) SWIG_fail;
30364 }
30365 {
30366 PyThreadState* __tstate = wxPyBeginAllowThreads();
30367 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
30368
30369 wxPyEndAllowThreads(__tstate);
30370 if (PyErr_Occurred()) SWIG_fail;
30371 }
30372 {
30373 resultobj = SWIG_From_int((int)(result));
30374 }
30375 return resultobj;
30376 fail:
30377 return NULL;
30378 }
30379
30380
30381 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
30382 PyObject *resultobj;
30383 wxWindow *arg1 = (wxWindow *) 0 ;
30384 int arg2 ;
30385 int result;
30386 PyObject * obj0 = 0 ;
30387 PyObject * obj1 = 0 ;
30388 char *kwnames[] = {
30389 (char *) "self",(char *) "orientation", NULL
30390 };
30391
30392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
30393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30394 if (SWIG_arg_fail(1)) SWIG_fail;
30395 {
30396 arg2 = (int)(SWIG_As_int(obj1));
30397 if (SWIG_arg_fail(2)) SWIG_fail;
30398 }
30399 {
30400 PyThreadState* __tstate = wxPyBeginAllowThreads();
30401 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
30402
30403 wxPyEndAllowThreads(__tstate);
30404 if (PyErr_Occurred()) SWIG_fail;
30405 }
30406 {
30407 resultobj = SWIG_From_int((int)(result));
30408 }
30409 return resultobj;
30410 fail:
30411 return NULL;
30412 }
30413
30414
30415 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30416 PyObject *resultobj;
30417 wxWindow *arg1 = (wxWindow *) 0 ;
30418 int arg2 ;
30419 int arg3 ;
30420 wxRect *arg4 = (wxRect *) NULL ;
30421 PyObject * obj0 = 0 ;
30422 PyObject * obj1 = 0 ;
30423 PyObject * obj2 = 0 ;
30424 PyObject * obj3 = 0 ;
30425 char *kwnames[] = {
30426 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
30427 };
30428
30429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30431 if (SWIG_arg_fail(1)) SWIG_fail;
30432 {
30433 arg2 = (int)(SWIG_As_int(obj1));
30434 if (SWIG_arg_fail(2)) SWIG_fail;
30435 }
30436 {
30437 arg3 = (int)(SWIG_As_int(obj2));
30438 if (SWIG_arg_fail(3)) SWIG_fail;
30439 }
30440 if (obj3) {
30441 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30442 if (SWIG_arg_fail(4)) SWIG_fail;
30443 }
30444 {
30445 PyThreadState* __tstate = wxPyBeginAllowThreads();
30446 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
30447
30448 wxPyEndAllowThreads(__tstate);
30449 if (PyErr_Occurred()) SWIG_fail;
30450 }
30451 Py_INCREF(Py_None); resultobj = Py_None;
30452 return resultobj;
30453 fail:
30454 return NULL;
30455 }
30456
30457
30458 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
30459 PyObject *resultobj;
30460 wxWindow *arg1 = (wxWindow *) 0 ;
30461 int arg2 ;
30462 bool result;
30463 PyObject * obj0 = 0 ;
30464 PyObject * obj1 = 0 ;
30465 char *kwnames[] = {
30466 (char *) "self",(char *) "lines", NULL
30467 };
30468
30469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
30470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30471 if (SWIG_arg_fail(1)) SWIG_fail;
30472 {
30473 arg2 = (int)(SWIG_As_int(obj1));
30474 if (SWIG_arg_fail(2)) SWIG_fail;
30475 }
30476 {
30477 PyThreadState* __tstate = wxPyBeginAllowThreads();
30478 result = (bool)(arg1)->ScrollLines(arg2);
30479
30480 wxPyEndAllowThreads(__tstate);
30481 if (PyErr_Occurred()) SWIG_fail;
30482 }
30483 {
30484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30485 }
30486 return resultobj;
30487 fail:
30488 return NULL;
30489 }
30490
30491
30492 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
30493 PyObject *resultobj;
30494 wxWindow *arg1 = (wxWindow *) 0 ;
30495 int arg2 ;
30496 bool result;
30497 PyObject * obj0 = 0 ;
30498 PyObject * obj1 = 0 ;
30499 char *kwnames[] = {
30500 (char *) "self",(char *) "pages", NULL
30501 };
30502
30503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
30504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30505 if (SWIG_arg_fail(1)) SWIG_fail;
30506 {
30507 arg2 = (int)(SWIG_As_int(obj1));
30508 if (SWIG_arg_fail(2)) SWIG_fail;
30509 }
30510 {
30511 PyThreadState* __tstate = wxPyBeginAllowThreads();
30512 result = (bool)(arg1)->ScrollPages(arg2);
30513
30514 wxPyEndAllowThreads(__tstate);
30515 if (PyErr_Occurred()) SWIG_fail;
30516 }
30517 {
30518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30519 }
30520 return resultobj;
30521 fail:
30522 return NULL;
30523 }
30524
30525
30526 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
30527 PyObject *resultobj;
30528 wxWindow *arg1 = (wxWindow *) 0 ;
30529 bool result;
30530 PyObject * obj0 = 0 ;
30531 char *kwnames[] = {
30532 (char *) "self", NULL
30533 };
30534
30535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
30536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30537 if (SWIG_arg_fail(1)) SWIG_fail;
30538 {
30539 PyThreadState* __tstate = wxPyBeginAllowThreads();
30540 result = (bool)(arg1)->LineUp();
30541
30542 wxPyEndAllowThreads(__tstate);
30543 if (PyErr_Occurred()) SWIG_fail;
30544 }
30545 {
30546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30547 }
30548 return resultobj;
30549 fail:
30550 return NULL;
30551 }
30552
30553
30554 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
30555 PyObject *resultobj;
30556 wxWindow *arg1 = (wxWindow *) 0 ;
30557 bool result;
30558 PyObject * obj0 = 0 ;
30559 char *kwnames[] = {
30560 (char *) "self", NULL
30561 };
30562
30563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
30564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30565 if (SWIG_arg_fail(1)) SWIG_fail;
30566 {
30567 PyThreadState* __tstate = wxPyBeginAllowThreads();
30568 result = (bool)(arg1)->LineDown();
30569
30570 wxPyEndAllowThreads(__tstate);
30571 if (PyErr_Occurred()) SWIG_fail;
30572 }
30573 {
30574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30575 }
30576 return resultobj;
30577 fail:
30578 return NULL;
30579 }
30580
30581
30582 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
30583 PyObject *resultobj;
30584 wxWindow *arg1 = (wxWindow *) 0 ;
30585 bool result;
30586 PyObject * obj0 = 0 ;
30587 char *kwnames[] = {
30588 (char *) "self", NULL
30589 };
30590
30591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
30592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30593 if (SWIG_arg_fail(1)) SWIG_fail;
30594 {
30595 PyThreadState* __tstate = wxPyBeginAllowThreads();
30596 result = (bool)(arg1)->PageUp();
30597
30598 wxPyEndAllowThreads(__tstate);
30599 if (PyErr_Occurred()) SWIG_fail;
30600 }
30601 {
30602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30603 }
30604 return resultobj;
30605 fail:
30606 return NULL;
30607 }
30608
30609
30610 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
30611 PyObject *resultobj;
30612 wxWindow *arg1 = (wxWindow *) 0 ;
30613 bool result;
30614 PyObject * obj0 = 0 ;
30615 char *kwnames[] = {
30616 (char *) "self", NULL
30617 };
30618
30619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
30620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30621 if (SWIG_arg_fail(1)) SWIG_fail;
30622 {
30623 PyThreadState* __tstate = wxPyBeginAllowThreads();
30624 result = (bool)(arg1)->PageDown();
30625
30626 wxPyEndAllowThreads(__tstate);
30627 if (PyErr_Occurred()) SWIG_fail;
30628 }
30629 {
30630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30631 }
30632 return resultobj;
30633 fail:
30634 return NULL;
30635 }
30636
30637
30638 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30639 PyObject *resultobj;
30640 wxWindow *arg1 = (wxWindow *) 0 ;
30641 wxString *arg2 = 0 ;
30642 bool temp2 = false ;
30643 PyObject * obj0 = 0 ;
30644 PyObject * obj1 = 0 ;
30645 char *kwnames[] = {
30646 (char *) "self",(char *) "text", NULL
30647 };
30648
30649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
30650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30651 if (SWIG_arg_fail(1)) SWIG_fail;
30652 {
30653 arg2 = wxString_in_helper(obj1);
30654 if (arg2 == NULL) SWIG_fail;
30655 temp2 = true;
30656 }
30657 {
30658 PyThreadState* __tstate = wxPyBeginAllowThreads();
30659 (arg1)->SetHelpText((wxString const &)*arg2);
30660
30661 wxPyEndAllowThreads(__tstate);
30662 if (PyErr_Occurred()) SWIG_fail;
30663 }
30664 Py_INCREF(Py_None); resultobj = Py_None;
30665 {
30666 if (temp2)
30667 delete arg2;
30668 }
30669 return resultobj;
30670 fail:
30671 {
30672 if (temp2)
30673 delete arg2;
30674 }
30675 return NULL;
30676 }
30677
30678
30679 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
30680 PyObject *resultobj;
30681 wxWindow *arg1 = (wxWindow *) 0 ;
30682 wxString *arg2 = 0 ;
30683 bool temp2 = false ;
30684 PyObject * obj0 = 0 ;
30685 PyObject * obj1 = 0 ;
30686 char *kwnames[] = {
30687 (char *) "self",(char *) "text", NULL
30688 };
30689
30690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
30691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30692 if (SWIG_arg_fail(1)) SWIG_fail;
30693 {
30694 arg2 = wxString_in_helper(obj1);
30695 if (arg2 == NULL) SWIG_fail;
30696 temp2 = true;
30697 }
30698 {
30699 PyThreadState* __tstate = wxPyBeginAllowThreads();
30700 (arg1)->SetHelpTextForId((wxString const &)*arg2);
30701
30702 wxPyEndAllowThreads(__tstate);
30703 if (PyErr_Occurred()) SWIG_fail;
30704 }
30705 Py_INCREF(Py_None); resultobj = Py_None;
30706 {
30707 if (temp2)
30708 delete arg2;
30709 }
30710 return resultobj;
30711 fail:
30712 {
30713 if (temp2)
30714 delete arg2;
30715 }
30716 return NULL;
30717 }
30718
30719
30720 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30721 PyObject *resultobj;
30722 wxWindow *arg1 = (wxWindow *) 0 ;
30723 wxString result;
30724 PyObject * obj0 = 0 ;
30725 char *kwnames[] = {
30726 (char *) "self", NULL
30727 };
30728
30729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
30730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30731 if (SWIG_arg_fail(1)) SWIG_fail;
30732 {
30733 PyThreadState* __tstate = wxPyBeginAllowThreads();
30734 result = ((wxWindow const *)arg1)->GetHelpText();
30735
30736 wxPyEndAllowThreads(__tstate);
30737 if (PyErr_Occurred()) SWIG_fail;
30738 }
30739 {
30740 #if wxUSE_UNICODE
30741 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30742 #else
30743 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30744 #endif
30745 }
30746 return resultobj;
30747 fail:
30748 return NULL;
30749 }
30750
30751
30752 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
30753 PyObject *resultobj;
30754 wxWindow *arg1 = (wxWindow *) 0 ;
30755 wxString *arg2 = 0 ;
30756 bool temp2 = false ;
30757 PyObject * obj0 = 0 ;
30758 PyObject * obj1 = 0 ;
30759 char *kwnames[] = {
30760 (char *) "self",(char *) "tip", NULL
30761 };
30762
30763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
30764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30765 if (SWIG_arg_fail(1)) SWIG_fail;
30766 {
30767 arg2 = wxString_in_helper(obj1);
30768 if (arg2 == NULL) SWIG_fail;
30769 temp2 = true;
30770 }
30771 {
30772 PyThreadState* __tstate = wxPyBeginAllowThreads();
30773 (arg1)->SetToolTip((wxString const &)*arg2);
30774
30775 wxPyEndAllowThreads(__tstate);
30776 if (PyErr_Occurred()) SWIG_fail;
30777 }
30778 Py_INCREF(Py_None); resultobj = Py_None;
30779 {
30780 if (temp2)
30781 delete arg2;
30782 }
30783 return resultobj;
30784 fail:
30785 {
30786 if (temp2)
30787 delete arg2;
30788 }
30789 return NULL;
30790 }
30791
30792
30793 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
30794 PyObject *resultobj;
30795 wxWindow *arg1 = (wxWindow *) 0 ;
30796 wxToolTip *arg2 = (wxToolTip *) 0 ;
30797 PyObject * obj0 = 0 ;
30798 PyObject * obj1 = 0 ;
30799 char *kwnames[] = {
30800 (char *) "self",(char *) "tip", NULL
30801 };
30802
30803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
30804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30805 if (SWIG_arg_fail(1)) SWIG_fail;
30806 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
30807 if (SWIG_arg_fail(2)) SWIG_fail;
30808 {
30809 PyThreadState* __tstate = wxPyBeginAllowThreads();
30810 (arg1)->SetToolTip(arg2);
30811
30812 wxPyEndAllowThreads(__tstate);
30813 if (PyErr_Occurred()) SWIG_fail;
30814 }
30815 Py_INCREF(Py_None); resultobj = Py_None;
30816 return resultobj;
30817 fail:
30818 return NULL;
30819 }
30820
30821
30822 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
30823 PyObject *resultobj;
30824 wxWindow *arg1 = (wxWindow *) 0 ;
30825 wxToolTip *result;
30826 PyObject * obj0 = 0 ;
30827 char *kwnames[] = {
30828 (char *) "self", NULL
30829 };
30830
30831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
30832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30833 if (SWIG_arg_fail(1)) SWIG_fail;
30834 {
30835 PyThreadState* __tstate = wxPyBeginAllowThreads();
30836 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
30837
30838 wxPyEndAllowThreads(__tstate);
30839 if (PyErr_Occurred()) SWIG_fail;
30840 }
30841 {
30842 resultobj = wxPyMake_wxObject(result, 0);
30843 }
30844 return resultobj;
30845 fail:
30846 return NULL;
30847 }
30848
30849
30850 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30851 PyObject *resultobj;
30852 wxWindow *arg1 = (wxWindow *) 0 ;
30853 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
30854 PyObject * obj0 = 0 ;
30855 PyObject * obj1 = 0 ;
30856 char *kwnames[] = {
30857 (char *) "self",(char *) "dropTarget", NULL
30858 };
30859
30860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
30861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30862 if (SWIG_arg_fail(1)) SWIG_fail;
30863 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30864 if (SWIG_arg_fail(2)) SWIG_fail;
30865 {
30866 PyThreadState* __tstate = wxPyBeginAllowThreads();
30867 (arg1)->SetDropTarget(arg2);
30868
30869 wxPyEndAllowThreads(__tstate);
30870 if (PyErr_Occurred()) SWIG_fail;
30871 }
30872 Py_INCREF(Py_None); resultobj = Py_None;
30873 return resultobj;
30874 fail:
30875 return NULL;
30876 }
30877
30878
30879 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30880 PyObject *resultobj;
30881 wxWindow *arg1 = (wxWindow *) 0 ;
30882 wxPyDropTarget *result;
30883 PyObject * obj0 = 0 ;
30884 char *kwnames[] = {
30885 (char *) "self", NULL
30886 };
30887
30888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
30889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30890 if (SWIG_arg_fail(1)) SWIG_fail;
30891 {
30892 PyThreadState* __tstate = wxPyBeginAllowThreads();
30893 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
30894
30895 wxPyEndAllowThreads(__tstate);
30896 if (PyErr_Occurred()) SWIG_fail;
30897 }
30898 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
30899 return resultobj;
30900 fail:
30901 return NULL;
30902 }
30903
30904
30905 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
30906 PyObject *resultobj;
30907 wxWindow *arg1 = (wxWindow *) 0 ;
30908 bool arg2 ;
30909 PyObject * obj0 = 0 ;
30910 PyObject * obj1 = 0 ;
30911 char *kwnames[] = {
30912 (char *) "self",(char *) "accept", NULL
30913 };
30914
30915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
30916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30917 if (SWIG_arg_fail(1)) SWIG_fail;
30918 {
30919 arg2 = (bool)(SWIG_As_bool(obj1));
30920 if (SWIG_arg_fail(2)) SWIG_fail;
30921 }
30922 {
30923 PyThreadState* __tstate = wxPyBeginAllowThreads();
30924 (arg1)->DragAcceptFiles(arg2);
30925
30926 wxPyEndAllowThreads(__tstate);
30927 if (PyErr_Occurred()) SWIG_fail;
30928 }
30929 Py_INCREF(Py_None); resultobj = Py_None;
30930 return resultobj;
30931 fail:
30932 return NULL;
30933 }
30934
30935
30936 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
30937 PyObject *resultobj;
30938 wxWindow *arg1 = (wxWindow *) 0 ;
30939 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
30940 PyObject * obj0 = 0 ;
30941 PyObject * obj1 = 0 ;
30942 char *kwnames[] = {
30943 (char *) "self",(char *) "constraints", NULL
30944 };
30945
30946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
30947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30948 if (SWIG_arg_fail(1)) SWIG_fail;
30949 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
30950 if (SWIG_arg_fail(2)) SWIG_fail;
30951 {
30952 PyThreadState* __tstate = wxPyBeginAllowThreads();
30953 (arg1)->SetConstraints(arg2);
30954
30955 wxPyEndAllowThreads(__tstate);
30956 if (PyErr_Occurred()) SWIG_fail;
30957 }
30958 Py_INCREF(Py_None); resultobj = Py_None;
30959 return resultobj;
30960 fail:
30961 return NULL;
30962 }
30963
30964
30965 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
30966 PyObject *resultobj;
30967 wxWindow *arg1 = (wxWindow *) 0 ;
30968 wxLayoutConstraints *result;
30969 PyObject * obj0 = 0 ;
30970 char *kwnames[] = {
30971 (char *) "self", NULL
30972 };
30973
30974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
30975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30976 if (SWIG_arg_fail(1)) SWIG_fail;
30977 {
30978 PyThreadState* __tstate = wxPyBeginAllowThreads();
30979 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
30980
30981 wxPyEndAllowThreads(__tstate);
30982 if (PyErr_Occurred()) SWIG_fail;
30983 }
30984 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
30985 return resultobj;
30986 fail:
30987 return NULL;
30988 }
30989
30990
30991 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
30992 PyObject *resultobj;
30993 wxWindow *arg1 = (wxWindow *) 0 ;
30994 bool arg2 ;
30995 PyObject * obj0 = 0 ;
30996 PyObject * obj1 = 0 ;
30997 char *kwnames[] = {
30998 (char *) "self",(char *) "autoLayout", NULL
30999 };
31000
31001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31003 if (SWIG_arg_fail(1)) SWIG_fail;
31004 {
31005 arg2 = (bool)(SWIG_As_bool(obj1));
31006 if (SWIG_arg_fail(2)) SWIG_fail;
31007 }
31008 {
31009 PyThreadState* __tstate = wxPyBeginAllowThreads();
31010 (arg1)->SetAutoLayout(arg2);
31011
31012 wxPyEndAllowThreads(__tstate);
31013 if (PyErr_Occurred()) SWIG_fail;
31014 }
31015 Py_INCREF(Py_None); resultobj = Py_None;
31016 return resultobj;
31017 fail:
31018 return NULL;
31019 }
31020
31021
31022 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31023 PyObject *resultobj;
31024 wxWindow *arg1 = (wxWindow *) 0 ;
31025 bool result;
31026 PyObject * obj0 = 0 ;
31027 char *kwnames[] = {
31028 (char *) "self", NULL
31029 };
31030
31031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31033 if (SWIG_arg_fail(1)) SWIG_fail;
31034 {
31035 PyThreadState* __tstate = wxPyBeginAllowThreads();
31036 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31037
31038 wxPyEndAllowThreads(__tstate);
31039 if (PyErr_Occurred()) SWIG_fail;
31040 }
31041 {
31042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31043 }
31044 return resultobj;
31045 fail:
31046 return NULL;
31047 }
31048
31049
31050 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31051 PyObject *resultobj;
31052 wxWindow *arg1 = (wxWindow *) 0 ;
31053 bool result;
31054 PyObject * obj0 = 0 ;
31055 char *kwnames[] = {
31056 (char *) "self", NULL
31057 };
31058
31059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31061 if (SWIG_arg_fail(1)) SWIG_fail;
31062 {
31063 PyThreadState* __tstate = wxPyBeginAllowThreads();
31064 result = (bool)(arg1)->Layout();
31065
31066 wxPyEndAllowThreads(__tstate);
31067 if (PyErr_Occurred()) SWIG_fail;
31068 }
31069 {
31070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31071 }
31072 return resultobj;
31073 fail:
31074 return NULL;
31075 }
31076
31077
31078 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31079 PyObject *resultobj;
31080 wxWindow *arg1 = (wxWindow *) 0 ;
31081 wxSizer *arg2 = (wxSizer *) 0 ;
31082 bool arg3 = (bool) true ;
31083 PyObject * obj0 = 0 ;
31084 PyObject * obj1 = 0 ;
31085 PyObject * obj2 = 0 ;
31086 char *kwnames[] = {
31087 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31088 };
31089
31090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31092 if (SWIG_arg_fail(1)) SWIG_fail;
31093 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31094 if (SWIG_arg_fail(2)) SWIG_fail;
31095 if (obj2) {
31096 {
31097 arg3 = (bool)(SWIG_As_bool(obj2));
31098 if (SWIG_arg_fail(3)) SWIG_fail;
31099 }
31100 }
31101 {
31102 PyThreadState* __tstate = wxPyBeginAllowThreads();
31103 (arg1)->SetSizer(arg2,arg3);
31104
31105 wxPyEndAllowThreads(__tstate);
31106 if (PyErr_Occurred()) SWIG_fail;
31107 }
31108 Py_INCREF(Py_None); resultobj = Py_None;
31109 return resultobj;
31110 fail:
31111 return NULL;
31112 }
31113
31114
31115 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31116 PyObject *resultobj;
31117 wxWindow *arg1 = (wxWindow *) 0 ;
31118 wxSizer *arg2 = (wxSizer *) 0 ;
31119 bool arg3 = (bool) true ;
31120 PyObject * obj0 = 0 ;
31121 PyObject * obj1 = 0 ;
31122 PyObject * obj2 = 0 ;
31123 char *kwnames[] = {
31124 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31125 };
31126
31127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31129 if (SWIG_arg_fail(1)) SWIG_fail;
31130 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31131 if (SWIG_arg_fail(2)) SWIG_fail;
31132 if (obj2) {
31133 {
31134 arg3 = (bool)(SWIG_As_bool(obj2));
31135 if (SWIG_arg_fail(3)) SWIG_fail;
31136 }
31137 }
31138 {
31139 PyThreadState* __tstate = wxPyBeginAllowThreads();
31140 (arg1)->SetSizerAndFit(arg2,arg3);
31141
31142 wxPyEndAllowThreads(__tstate);
31143 if (PyErr_Occurred()) SWIG_fail;
31144 }
31145 Py_INCREF(Py_None); resultobj = Py_None;
31146 return resultobj;
31147 fail:
31148 return NULL;
31149 }
31150
31151
31152 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31153 PyObject *resultobj;
31154 wxWindow *arg1 = (wxWindow *) 0 ;
31155 wxSizer *result;
31156 PyObject * obj0 = 0 ;
31157 char *kwnames[] = {
31158 (char *) "self", NULL
31159 };
31160
31161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31163 if (SWIG_arg_fail(1)) SWIG_fail;
31164 {
31165 PyThreadState* __tstate = wxPyBeginAllowThreads();
31166 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31167
31168 wxPyEndAllowThreads(__tstate);
31169 if (PyErr_Occurred()) SWIG_fail;
31170 }
31171 {
31172 resultobj = wxPyMake_wxSizer(result, 0);
31173 }
31174 return resultobj;
31175 fail:
31176 return NULL;
31177 }
31178
31179
31180 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31181 PyObject *resultobj;
31182 wxWindow *arg1 = (wxWindow *) 0 ;
31183 wxSizer *arg2 = (wxSizer *) 0 ;
31184 PyObject * obj0 = 0 ;
31185 PyObject * obj1 = 0 ;
31186 char *kwnames[] = {
31187 (char *) "self",(char *) "sizer", NULL
31188 };
31189
31190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31192 if (SWIG_arg_fail(1)) SWIG_fail;
31193 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31194 if (SWIG_arg_fail(2)) SWIG_fail;
31195 {
31196 PyThreadState* __tstate = wxPyBeginAllowThreads();
31197 (arg1)->SetContainingSizer(arg2);
31198
31199 wxPyEndAllowThreads(__tstate);
31200 if (PyErr_Occurred()) SWIG_fail;
31201 }
31202 Py_INCREF(Py_None); resultobj = Py_None;
31203 return resultobj;
31204 fail:
31205 return NULL;
31206 }
31207
31208
31209 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31210 PyObject *resultobj;
31211 wxWindow *arg1 = (wxWindow *) 0 ;
31212 wxSizer *result;
31213 PyObject * obj0 = 0 ;
31214 char *kwnames[] = {
31215 (char *) "self", NULL
31216 };
31217
31218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31220 if (SWIG_arg_fail(1)) SWIG_fail;
31221 {
31222 PyThreadState* __tstate = wxPyBeginAllowThreads();
31223 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31224
31225 wxPyEndAllowThreads(__tstate);
31226 if (PyErr_Occurred()) SWIG_fail;
31227 }
31228 {
31229 resultobj = wxPyMake_wxSizer(result, 0);
31230 }
31231 return resultobj;
31232 fail:
31233 return NULL;
31234 }
31235
31236
31237 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31238 PyObject *resultobj;
31239 wxWindow *arg1 = (wxWindow *) 0 ;
31240 PyObject * obj0 = 0 ;
31241 char *kwnames[] = {
31242 (char *) "self", NULL
31243 };
31244
31245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31247 if (SWIG_arg_fail(1)) SWIG_fail;
31248 {
31249 PyThreadState* __tstate = wxPyBeginAllowThreads();
31250 (arg1)->InheritAttributes();
31251
31252 wxPyEndAllowThreads(__tstate);
31253 if (PyErr_Occurred()) SWIG_fail;
31254 }
31255 Py_INCREF(Py_None); resultobj = Py_None;
31256 return resultobj;
31257 fail:
31258 return NULL;
31259 }
31260
31261
31262 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31263 PyObject *resultobj;
31264 wxWindow *arg1 = (wxWindow *) 0 ;
31265 bool result;
31266 PyObject * obj0 = 0 ;
31267 char *kwnames[] = {
31268 (char *) "self", NULL
31269 };
31270
31271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
31276 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31277
31278 wxPyEndAllowThreads(__tstate);
31279 if (PyErr_Occurred()) SWIG_fail;
31280 }
31281 {
31282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31283 }
31284 return resultobj;
31285 fail:
31286 return NULL;
31287 }
31288
31289
31290 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31291 PyObject *obj;
31292 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31293 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31294 Py_INCREF(obj);
31295 return Py_BuildValue((char *)"");
31296 }
31297 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31298 PyObject *resultobj;
31299 long arg1 ;
31300 wxWindow *arg2 = (wxWindow *) NULL ;
31301 wxWindow *result;
31302 PyObject * obj0 = 0 ;
31303 PyObject * obj1 = 0 ;
31304 char *kwnames[] = {
31305 (char *) "id",(char *) "parent", NULL
31306 };
31307
31308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31309 {
31310 arg1 = (long)(SWIG_As_long(obj0));
31311 if (SWIG_arg_fail(1)) SWIG_fail;
31312 }
31313 if (obj1) {
31314 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31315 if (SWIG_arg_fail(2)) SWIG_fail;
31316 }
31317 {
31318 if (!wxPyCheckForApp()) SWIG_fail;
31319 PyThreadState* __tstate = wxPyBeginAllowThreads();
31320 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31321
31322 wxPyEndAllowThreads(__tstate);
31323 if (PyErr_Occurred()) SWIG_fail;
31324 }
31325 {
31326 resultobj = wxPyMake_wxObject(result, 0);
31327 }
31328 return resultobj;
31329 fail:
31330 return NULL;
31331 }
31332
31333
31334 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31335 PyObject *resultobj;
31336 wxString *arg1 = 0 ;
31337 wxWindow *arg2 = (wxWindow *) NULL ;
31338 wxWindow *result;
31339 bool temp1 = false ;
31340 PyObject * obj0 = 0 ;
31341 PyObject * obj1 = 0 ;
31342 char *kwnames[] = {
31343 (char *) "name",(char *) "parent", NULL
31344 };
31345
31346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31347 {
31348 arg1 = wxString_in_helper(obj0);
31349 if (arg1 == NULL) SWIG_fail;
31350 temp1 = true;
31351 }
31352 if (obj1) {
31353 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31354 if (SWIG_arg_fail(2)) SWIG_fail;
31355 }
31356 {
31357 if (!wxPyCheckForApp()) SWIG_fail;
31358 PyThreadState* __tstate = wxPyBeginAllowThreads();
31359 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31360
31361 wxPyEndAllowThreads(__tstate);
31362 if (PyErr_Occurred()) SWIG_fail;
31363 }
31364 {
31365 resultobj = wxPyMake_wxObject(result, 0);
31366 }
31367 {
31368 if (temp1)
31369 delete arg1;
31370 }
31371 return resultobj;
31372 fail:
31373 {
31374 if (temp1)
31375 delete arg1;
31376 }
31377 return NULL;
31378 }
31379
31380
31381 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
31382 PyObject *resultobj;
31383 wxString *arg1 = 0 ;
31384 wxWindow *arg2 = (wxWindow *) NULL ;
31385 wxWindow *result;
31386 bool temp1 = false ;
31387 PyObject * obj0 = 0 ;
31388 PyObject * obj1 = 0 ;
31389 char *kwnames[] = {
31390 (char *) "label",(char *) "parent", NULL
31391 };
31392
31393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
31394 {
31395 arg1 = wxString_in_helper(obj0);
31396 if (arg1 == NULL) SWIG_fail;
31397 temp1 = true;
31398 }
31399 if (obj1) {
31400 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31401 if (SWIG_arg_fail(2)) SWIG_fail;
31402 }
31403 {
31404 if (!wxPyCheckForApp()) SWIG_fail;
31405 PyThreadState* __tstate = wxPyBeginAllowThreads();
31406 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
31407
31408 wxPyEndAllowThreads(__tstate);
31409 if (PyErr_Occurred()) SWIG_fail;
31410 }
31411 {
31412 resultobj = wxPyMake_wxObject(result, 0);
31413 }
31414 {
31415 if (temp1)
31416 delete arg1;
31417 }
31418 return resultobj;
31419 fail:
31420 {
31421 if (temp1)
31422 delete arg1;
31423 }
31424 return NULL;
31425 }
31426
31427
31428 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
31429 PyObject *resultobj;
31430 wxWindow *arg1 = (wxWindow *) 0 ;
31431 unsigned long arg2 ;
31432 wxWindow *result;
31433 PyObject * obj0 = 0 ;
31434 PyObject * obj1 = 0 ;
31435 char *kwnames[] = {
31436 (char *) "parent",(char *) "_hWnd", NULL
31437 };
31438
31439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
31440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31441 if (SWIG_arg_fail(1)) SWIG_fail;
31442 {
31443 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
31444 if (SWIG_arg_fail(2)) SWIG_fail;
31445 }
31446 {
31447 PyThreadState* __tstate = wxPyBeginAllowThreads();
31448 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
31449
31450 wxPyEndAllowThreads(__tstate);
31451 if (PyErr_Occurred()) SWIG_fail;
31452 }
31453 {
31454 resultobj = wxPyMake_wxObject(result, 0);
31455 }
31456 return resultobj;
31457 fail:
31458 return NULL;
31459 }
31460
31461
31462 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
31463 PyObject *resultobj;
31464 wxValidator *result;
31465 char *kwnames[] = {
31466 NULL
31467 };
31468
31469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
31470 {
31471 PyThreadState* __tstate = wxPyBeginAllowThreads();
31472 result = (wxValidator *)new wxValidator();
31473
31474 wxPyEndAllowThreads(__tstate);
31475 if (PyErr_Occurred()) SWIG_fail;
31476 }
31477 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
31478 return resultobj;
31479 fail:
31480 return NULL;
31481 }
31482
31483
31484 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
31485 PyObject *resultobj;
31486 wxValidator *arg1 = (wxValidator *) 0 ;
31487 wxValidator *result;
31488 PyObject * obj0 = 0 ;
31489 char *kwnames[] = {
31490 (char *) "self", NULL
31491 };
31492
31493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
31494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31495 if (SWIG_arg_fail(1)) SWIG_fail;
31496 {
31497 PyThreadState* __tstate = wxPyBeginAllowThreads();
31498 result = (wxValidator *)(arg1)->Clone();
31499
31500 wxPyEndAllowThreads(__tstate);
31501 if (PyErr_Occurred()) SWIG_fail;
31502 }
31503 {
31504 resultobj = wxPyMake_wxObject(result, 0);
31505 }
31506 return resultobj;
31507 fail:
31508 return NULL;
31509 }
31510
31511
31512 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
31513 PyObject *resultobj;
31514 wxValidator *arg1 = (wxValidator *) 0 ;
31515 wxWindow *arg2 = (wxWindow *) 0 ;
31516 bool result;
31517 PyObject * obj0 = 0 ;
31518 PyObject * obj1 = 0 ;
31519 char *kwnames[] = {
31520 (char *) "self",(char *) "parent", NULL
31521 };
31522
31523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
31524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31525 if (SWIG_arg_fail(1)) SWIG_fail;
31526 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31527 if (SWIG_arg_fail(2)) SWIG_fail;
31528 {
31529 PyThreadState* __tstate = wxPyBeginAllowThreads();
31530 result = (bool)(arg1)->Validate(arg2);
31531
31532 wxPyEndAllowThreads(__tstate);
31533 if (PyErr_Occurred()) SWIG_fail;
31534 }
31535 {
31536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31537 }
31538 return resultobj;
31539 fail:
31540 return NULL;
31541 }
31542
31543
31544 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31545 PyObject *resultobj;
31546 wxValidator *arg1 = (wxValidator *) 0 ;
31547 bool result;
31548 PyObject * obj0 = 0 ;
31549 char *kwnames[] = {
31550 (char *) "self", NULL
31551 };
31552
31553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
31554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31555 if (SWIG_arg_fail(1)) SWIG_fail;
31556 {
31557 PyThreadState* __tstate = wxPyBeginAllowThreads();
31558 result = (bool)(arg1)->TransferToWindow();
31559
31560 wxPyEndAllowThreads(__tstate);
31561 if (PyErr_Occurred()) SWIG_fail;
31562 }
31563 {
31564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31565 }
31566 return resultobj;
31567 fail:
31568 return NULL;
31569 }
31570
31571
31572 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31573 PyObject *resultobj;
31574 wxValidator *arg1 = (wxValidator *) 0 ;
31575 bool result;
31576 PyObject * obj0 = 0 ;
31577 char *kwnames[] = {
31578 (char *) "self", NULL
31579 };
31580
31581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
31582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31583 if (SWIG_arg_fail(1)) SWIG_fail;
31584 {
31585 PyThreadState* __tstate = wxPyBeginAllowThreads();
31586 result = (bool)(arg1)->TransferFromWindow();
31587
31588 wxPyEndAllowThreads(__tstate);
31589 if (PyErr_Occurred()) SWIG_fail;
31590 }
31591 {
31592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31593 }
31594 return resultobj;
31595 fail:
31596 return NULL;
31597 }
31598
31599
31600 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31601 PyObject *resultobj;
31602 wxValidator *arg1 = (wxValidator *) 0 ;
31603 wxWindow *result;
31604 PyObject * obj0 = 0 ;
31605 char *kwnames[] = {
31606 (char *) "self", NULL
31607 };
31608
31609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
31610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31611 if (SWIG_arg_fail(1)) SWIG_fail;
31612 {
31613 PyThreadState* __tstate = wxPyBeginAllowThreads();
31614 result = (wxWindow *)(arg1)->GetWindow();
31615
31616 wxPyEndAllowThreads(__tstate);
31617 if (PyErr_Occurred()) SWIG_fail;
31618 }
31619 {
31620 resultobj = wxPyMake_wxObject(result, 0);
31621 }
31622 return resultobj;
31623 fail:
31624 return NULL;
31625 }
31626
31627
31628 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31629 PyObject *resultobj;
31630 wxValidator *arg1 = (wxValidator *) 0 ;
31631 wxWindow *arg2 = (wxWindow *) 0 ;
31632 PyObject * obj0 = 0 ;
31633 PyObject * obj1 = 0 ;
31634 char *kwnames[] = {
31635 (char *) "self",(char *) "window", NULL
31636 };
31637
31638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
31639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31640 if (SWIG_arg_fail(1)) SWIG_fail;
31641 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31642 if (SWIG_arg_fail(2)) SWIG_fail;
31643 {
31644 PyThreadState* __tstate = wxPyBeginAllowThreads();
31645 (arg1)->SetWindow(arg2);
31646
31647 wxPyEndAllowThreads(__tstate);
31648 if (PyErr_Occurred()) SWIG_fail;
31649 }
31650 Py_INCREF(Py_None); resultobj = Py_None;
31651 return resultobj;
31652 fail:
31653 return NULL;
31654 }
31655
31656
31657 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
31658 PyObject *resultobj;
31659 bool result;
31660 char *kwnames[] = {
31661 NULL
31662 };
31663
31664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
31665 {
31666 PyThreadState* __tstate = wxPyBeginAllowThreads();
31667 result = (bool)wxValidator::IsSilent();
31668
31669 wxPyEndAllowThreads(__tstate);
31670 if (PyErr_Occurred()) SWIG_fail;
31671 }
31672 {
31673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31674 }
31675 return resultobj;
31676 fail:
31677 return NULL;
31678 }
31679
31680
31681 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
31682 PyObject *resultobj;
31683 int arg1 = (int) true ;
31684 PyObject * obj0 = 0 ;
31685 char *kwnames[] = {
31686 (char *) "doIt", NULL
31687 };
31688
31689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
31690 if (obj0) {
31691 {
31692 arg1 = (int)(SWIG_As_int(obj0));
31693 if (SWIG_arg_fail(1)) SWIG_fail;
31694 }
31695 }
31696 {
31697 PyThreadState* __tstate = wxPyBeginAllowThreads();
31698 wxValidator::SetBellOnError(arg1);
31699
31700 wxPyEndAllowThreads(__tstate);
31701 if (PyErr_Occurred()) SWIG_fail;
31702 }
31703 Py_INCREF(Py_None); resultobj = Py_None;
31704 return resultobj;
31705 fail:
31706 return NULL;
31707 }
31708
31709
31710 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
31711 PyObject *obj;
31712 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31713 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
31714 Py_INCREF(obj);
31715 return Py_BuildValue((char *)"");
31716 }
31717 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
31718 PyObject *resultobj;
31719 wxPyValidator *result;
31720 char *kwnames[] = {
31721 NULL
31722 };
31723
31724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
31725 {
31726 PyThreadState* __tstate = wxPyBeginAllowThreads();
31727 result = (wxPyValidator *)new wxPyValidator();
31728
31729 wxPyEndAllowThreads(__tstate);
31730 if (PyErr_Occurred()) SWIG_fail;
31731 }
31732 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
31733 return resultobj;
31734 fail:
31735 return NULL;
31736 }
31737
31738
31739 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
31740 PyObject *resultobj;
31741 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
31742 PyObject *arg2 = (PyObject *) 0 ;
31743 PyObject *arg3 = (PyObject *) 0 ;
31744 int arg4 = (int) true ;
31745 PyObject * obj0 = 0 ;
31746 PyObject * obj1 = 0 ;
31747 PyObject * obj2 = 0 ;
31748 PyObject * obj3 = 0 ;
31749 char *kwnames[] = {
31750 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
31751 };
31752
31753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
31755 if (SWIG_arg_fail(1)) SWIG_fail;
31756 arg2 = obj1;
31757 arg3 = obj2;
31758 if (obj3) {
31759 {
31760 arg4 = (int)(SWIG_As_int(obj3));
31761 if (SWIG_arg_fail(4)) SWIG_fail;
31762 }
31763 }
31764 {
31765 PyThreadState* __tstate = wxPyBeginAllowThreads();
31766 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
31767
31768 wxPyEndAllowThreads(__tstate);
31769 if (PyErr_Occurred()) SWIG_fail;
31770 }
31771 Py_INCREF(Py_None); resultobj = Py_None;
31772 return resultobj;
31773 fail:
31774 return NULL;
31775 }
31776
31777
31778 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
31779 PyObject *obj;
31780 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31781 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
31782 Py_INCREF(obj);
31783 return Py_BuildValue((char *)"");
31784 }
31785 static int _wrap_DefaultValidator_set(PyObject *) {
31786 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
31787 return 1;
31788 }
31789
31790
31791 static PyObject *_wrap_DefaultValidator_get(void) {
31792 PyObject *pyobj;
31793
31794 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
31795 return pyobj;
31796 }
31797
31798
31799 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
31800 PyObject *resultobj;
31801 wxString const &arg1_defvalue = wxPyEmptyString ;
31802 wxString *arg1 = (wxString *) &arg1_defvalue ;
31803 long arg2 = (long) 0 ;
31804 wxMenu *result;
31805 bool temp1 = false ;
31806 PyObject * obj0 = 0 ;
31807 PyObject * obj1 = 0 ;
31808 char *kwnames[] = {
31809 (char *) "title",(char *) "style", NULL
31810 };
31811
31812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
31813 if (obj0) {
31814 {
31815 arg1 = wxString_in_helper(obj0);
31816 if (arg1 == NULL) SWIG_fail;
31817 temp1 = true;
31818 }
31819 }
31820 if (obj1) {
31821 {
31822 arg2 = (long)(SWIG_As_long(obj1));
31823 if (SWIG_arg_fail(2)) SWIG_fail;
31824 }
31825 }
31826 {
31827 if (!wxPyCheckForApp()) SWIG_fail;
31828 PyThreadState* __tstate = wxPyBeginAllowThreads();
31829 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
31830
31831 wxPyEndAllowThreads(__tstate);
31832 if (PyErr_Occurred()) SWIG_fail;
31833 }
31834 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
31835 {
31836 if (temp1)
31837 delete arg1;
31838 }
31839 return resultobj;
31840 fail:
31841 {
31842 if (temp1)
31843 delete arg1;
31844 }
31845 return NULL;
31846 }
31847
31848
31849 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
31850 PyObject *resultobj;
31851 wxMenu *arg1 = (wxMenu *) 0 ;
31852 int arg2 ;
31853 wxString *arg3 = 0 ;
31854 wxString const &arg4_defvalue = wxPyEmptyString ;
31855 wxString *arg4 = (wxString *) &arg4_defvalue ;
31856 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
31857 wxMenuItem *result;
31858 bool temp3 = false ;
31859 bool temp4 = false ;
31860 PyObject * obj0 = 0 ;
31861 PyObject * obj1 = 0 ;
31862 PyObject * obj2 = 0 ;
31863 PyObject * obj3 = 0 ;
31864 PyObject * obj4 = 0 ;
31865 char *kwnames[] = {
31866 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
31867 };
31868
31869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
31870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31871 if (SWIG_arg_fail(1)) SWIG_fail;
31872 {
31873 arg2 = (int)(SWIG_As_int(obj1));
31874 if (SWIG_arg_fail(2)) SWIG_fail;
31875 }
31876 {
31877 arg3 = wxString_in_helper(obj2);
31878 if (arg3 == NULL) SWIG_fail;
31879 temp3 = true;
31880 }
31881 if (obj3) {
31882 {
31883 arg4 = wxString_in_helper(obj3);
31884 if (arg4 == NULL) SWIG_fail;
31885 temp4 = true;
31886 }
31887 }
31888 if (obj4) {
31889 {
31890 arg5 = (wxItemKind)(SWIG_As_int(obj4));
31891 if (SWIG_arg_fail(5)) SWIG_fail;
31892 }
31893 }
31894 {
31895 PyThreadState* __tstate = wxPyBeginAllowThreads();
31896 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
31897
31898 wxPyEndAllowThreads(__tstate);
31899 if (PyErr_Occurred()) SWIG_fail;
31900 }
31901 {
31902 resultobj = wxPyMake_wxObject(result, 0);
31903 }
31904 {
31905 if (temp3)
31906 delete arg3;
31907 }
31908 {
31909 if (temp4)
31910 delete arg4;
31911 }
31912 return resultobj;
31913 fail:
31914 {
31915 if (temp3)
31916 delete arg3;
31917 }
31918 {
31919 if (temp4)
31920 delete arg4;
31921 }
31922 return NULL;
31923 }
31924
31925
31926 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
31927 PyObject *resultobj;
31928 wxMenu *arg1 = (wxMenu *) 0 ;
31929 wxMenuItem *result;
31930 PyObject * obj0 = 0 ;
31931 char *kwnames[] = {
31932 (char *) "self", NULL
31933 };
31934
31935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
31936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31937 if (SWIG_arg_fail(1)) SWIG_fail;
31938 {
31939 PyThreadState* __tstate = wxPyBeginAllowThreads();
31940 result = (wxMenuItem *)(arg1)->AppendSeparator();
31941
31942 wxPyEndAllowThreads(__tstate);
31943 if (PyErr_Occurred()) SWIG_fail;
31944 }
31945 {
31946 resultobj = wxPyMake_wxObject(result, 0);
31947 }
31948 return resultobj;
31949 fail:
31950 return NULL;
31951 }
31952
31953
31954 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
31955 PyObject *resultobj;
31956 wxMenu *arg1 = (wxMenu *) 0 ;
31957 int arg2 ;
31958 wxString *arg3 = 0 ;
31959 wxString const &arg4_defvalue = wxPyEmptyString ;
31960 wxString *arg4 = (wxString *) &arg4_defvalue ;
31961 wxMenuItem *result;
31962 bool temp3 = false ;
31963 bool temp4 = false ;
31964 PyObject * obj0 = 0 ;
31965 PyObject * obj1 = 0 ;
31966 PyObject * obj2 = 0 ;
31967 PyObject * obj3 = 0 ;
31968 char *kwnames[] = {
31969 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
31970 };
31971
31972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31974 if (SWIG_arg_fail(1)) SWIG_fail;
31975 {
31976 arg2 = (int)(SWIG_As_int(obj1));
31977 if (SWIG_arg_fail(2)) SWIG_fail;
31978 }
31979 {
31980 arg3 = wxString_in_helper(obj2);
31981 if (arg3 == NULL) SWIG_fail;
31982 temp3 = true;
31983 }
31984 if (obj3) {
31985 {
31986 arg4 = wxString_in_helper(obj3);
31987 if (arg4 == NULL) SWIG_fail;
31988 temp4 = true;
31989 }
31990 }
31991 {
31992 PyThreadState* __tstate = wxPyBeginAllowThreads();
31993 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
31994
31995 wxPyEndAllowThreads(__tstate);
31996 if (PyErr_Occurred()) SWIG_fail;
31997 }
31998 {
31999 resultobj = wxPyMake_wxObject(result, 0);
32000 }
32001 {
32002 if (temp3)
32003 delete arg3;
32004 }
32005 {
32006 if (temp4)
32007 delete arg4;
32008 }
32009 return resultobj;
32010 fail:
32011 {
32012 if (temp3)
32013 delete arg3;
32014 }
32015 {
32016 if (temp4)
32017 delete arg4;
32018 }
32019 return NULL;
32020 }
32021
32022
32023 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32024 PyObject *resultobj;
32025 wxMenu *arg1 = (wxMenu *) 0 ;
32026 int arg2 ;
32027 wxString *arg3 = 0 ;
32028 wxString const &arg4_defvalue = wxPyEmptyString ;
32029 wxString *arg4 = (wxString *) &arg4_defvalue ;
32030 wxMenuItem *result;
32031 bool temp3 = false ;
32032 bool temp4 = false ;
32033 PyObject * obj0 = 0 ;
32034 PyObject * obj1 = 0 ;
32035 PyObject * obj2 = 0 ;
32036 PyObject * obj3 = 0 ;
32037 char *kwnames[] = {
32038 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32039 };
32040
32041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32043 if (SWIG_arg_fail(1)) SWIG_fail;
32044 {
32045 arg2 = (int)(SWIG_As_int(obj1));
32046 if (SWIG_arg_fail(2)) SWIG_fail;
32047 }
32048 {
32049 arg3 = wxString_in_helper(obj2);
32050 if (arg3 == NULL) SWIG_fail;
32051 temp3 = true;
32052 }
32053 if (obj3) {
32054 {
32055 arg4 = wxString_in_helper(obj3);
32056 if (arg4 == NULL) SWIG_fail;
32057 temp4 = true;
32058 }
32059 }
32060 {
32061 PyThreadState* __tstate = wxPyBeginAllowThreads();
32062 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32063
32064 wxPyEndAllowThreads(__tstate);
32065 if (PyErr_Occurred()) SWIG_fail;
32066 }
32067 {
32068 resultobj = wxPyMake_wxObject(result, 0);
32069 }
32070 {
32071 if (temp3)
32072 delete arg3;
32073 }
32074 {
32075 if (temp4)
32076 delete arg4;
32077 }
32078 return resultobj;
32079 fail:
32080 {
32081 if (temp3)
32082 delete arg3;
32083 }
32084 {
32085 if (temp4)
32086 delete arg4;
32087 }
32088 return NULL;
32089 }
32090
32091
32092 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32093 PyObject *resultobj;
32094 wxMenu *arg1 = (wxMenu *) 0 ;
32095 int arg2 ;
32096 wxString *arg3 = 0 ;
32097 wxMenu *arg4 = (wxMenu *) 0 ;
32098 wxString const &arg5_defvalue = wxPyEmptyString ;
32099 wxString *arg5 = (wxString *) &arg5_defvalue ;
32100 wxMenuItem *result;
32101 bool temp3 = false ;
32102 bool temp5 = false ;
32103 PyObject * obj0 = 0 ;
32104 PyObject * obj1 = 0 ;
32105 PyObject * obj2 = 0 ;
32106 PyObject * obj3 = 0 ;
32107 PyObject * obj4 = 0 ;
32108 char *kwnames[] = {
32109 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32110 };
32111
32112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32114 if (SWIG_arg_fail(1)) SWIG_fail;
32115 {
32116 arg2 = (int)(SWIG_As_int(obj1));
32117 if (SWIG_arg_fail(2)) SWIG_fail;
32118 }
32119 {
32120 arg3 = wxString_in_helper(obj2);
32121 if (arg3 == NULL) SWIG_fail;
32122 temp3 = true;
32123 }
32124 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32125 if (SWIG_arg_fail(4)) SWIG_fail;
32126 if (obj4) {
32127 {
32128 arg5 = wxString_in_helper(obj4);
32129 if (arg5 == NULL) SWIG_fail;
32130 temp5 = true;
32131 }
32132 }
32133 {
32134 PyThreadState* __tstate = wxPyBeginAllowThreads();
32135 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32136
32137 wxPyEndAllowThreads(__tstate);
32138 if (PyErr_Occurred()) SWIG_fail;
32139 }
32140 {
32141 resultobj = wxPyMake_wxObject(result, 0);
32142 }
32143 {
32144 if (temp3)
32145 delete arg3;
32146 }
32147 {
32148 if (temp5)
32149 delete arg5;
32150 }
32151 return resultobj;
32152 fail:
32153 {
32154 if (temp3)
32155 delete arg3;
32156 }
32157 {
32158 if (temp5)
32159 delete arg5;
32160 }
32161 return NULL;
32162 }
32163
32164
32165 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32166 PyObject *resultobj;
32167 wxMenu *arg1 = (wxMenu *) 0 ;
32168 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32169 wxMenuItem *result;
32170 PyObject * obj0 = 0 ;
32171 PyObject * obj1 = 0 ;
32172 char *kwnames[] = {
32173 (char *) "self",(char *) "item", NULL
32174 };
32175
32176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32178 if (SWIG_arg_fail(1)) SWIG_fail;
32179 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32180 if (SWIG_arg_fail(2)) SWIG_fail;
32181 {
32182 PyThreadState* __tstate = wxPyBeginAllowThreads();
32183 result = (wxMenuItem *)(arg1)->Append(arg2);
32184
32185 wxPyEndAllowThreads(__tstate);
32186 if (PyErr_Occurred()) SWIG_fail;
32187 }
32188 {
32189 resultobj = wxPyMake_wxObject(result, 0);
32190 }
32191 return resultobj;
32192 fail:
32193 return NULL;
32194 }
32195
32196
32197 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32198 PyObject *resultobj;
32199 wxMenu *arg1 = (wxMenu *) 0 ;
32200 PyObject * obj0 = 0 ;
32201 char *kwnames[] = {
32202 (char *) "self", NULL
32203 };
32204
32205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32207 if (SWIG_arg_fail(1)) SWIG_fail;
32208 {
32209 PyThreadState* __tstate = wxPyBeginAllowThreads();
32210 (arg1)->Break();
32211
32212 wxPyEndAllowThreads(__tstate);
32213 if (PyErr_Occurred()) SWIG_fail;
32214 }
32215 Py_INCREF(Py_None); resultobj = Py_None;
32216 return resultobj;
32217 fail:
32218 return NULL;
32219 }
32220
32221
32222 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32223 PyObject *resultobj;
32224 wxMenu *arg1 = (wxMenu *) 0 ;
32225 size_t arg2 ;
32226 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32227 wxMenuItem *result;
32228 PyObject * obj0 = 0 ;
32229 PyObject * obj1 = 0 ;
32230 PyObject * obj2 = 0 ;
32231 char *kwnames[] = {
32232 (char *) "self",(char *) "pos",(char *) "item", NULL
32233 };
32234
32235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32237 if (SWIG_arg_fail(1)) SWIG_fail;
32238 {
32239 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32240 if (SWIG_arg_fail(2)) SWIG_fail;
32241 }
32242 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32243 if (SWIG_arg_fail(3)) SWIG_fail;
32244 {
32245 PyThreadState* __tstate = wxPyBeginAllowThreads();
32246 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32247
32248 wxPyEndAllowThreads(__tstate);
32249 if (PyErr_Occurred()) SWIG_fail;
32250 }
32251 {
32252 resultobj = wxPyMake_wxObject(result, 0);
32253 }
32254 return resultobj;
32255 fail:
32256 return NULL;
32257 }
32258
32259
32260 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32261 PyObject *resultobj;
32262 wxMenu *arg1 = (wxMenu *) 0 ;
32263 size_t arg2 ;
32264 int arg3 ;
32265 wxString *arg4 = 0 ;
32266 wxString const &arg5_defvalue = wxPyEmptyString ;
32267 wxString *arg5 = (wxString *) &arg5_defvalue ;
32268 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32269 wxMenuItem *result;
32270 bool temp4 = false ;
32271 bool temp5 = false ;
32272 PyObject * obj0 = 0 ;
32273 PyObject * obj1 = 0 ;
32274 PyObject * obj2 = 0 ;
32275 PyObject * obj3 = 0 ;
32276 PyObject * obj4 = 0 ;
32277 PyObject * obj5 = 0 ;
32278 char *kwnames[] = {
32279 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32280 };
32281
32282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32284 if (SWIG_arg_fail(1)) SWIG_fail;
32285 {
32286 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32287 if (SWIG_arg_fail(2)) SWIG_fail;
32288 }
32289 {
32290 arg3 = (int)(SWIG_As_int(obj2));
32291 if (SWIG_arg_fail(3)) SWIG_fail;
32292 }
32293 {
32294 arg4 = wxString_in_helper(obj3);
32295 if (arg4 == NULL) SWIG_fail;
32296 temp4 = true;
32297 }
32298 if (obj4) {
32299 {
32300 arg5 = wxString_in_helper(obj4);
32301 if (arg5 == NULL) SWIG_fail;
32302 temp5 = true;
32303 }
32304 }
32305 if (obj5) {
32306 {
32307 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32308 if (SWIG_arg_fail(6)) SWIG_fail;
32309 }
32310 }
32311 {
32312 PyThreadState* __tstate = wxPyBeginAllowThreads();
32313 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32314
32315 wxPyEndAllowThreads(__tstate);
32316 if (PyErr_Occurred()) SWIG_fail;
32317 }
32318 {
32319 resultobj = wxPyMake_wxObject(result, 0);
32320 }
32321 {
32322 if (temp4)
32323 delete arg4;
32324 }
32325 {
32326 if (temp5)
32327 delete arg5;
32328 }
32329 return resultobj;
32330 fail:
32331 {
32332 if (temp4)
32333 delete arg4;
32334 }
32335 {
32336 if (temp5)
32337 delete arg5;
32338 }
32339 return NULL;
32340 }
32341
32342
32343 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32344 PyObject *resultobj;
32345 wxMenu *arg1 = (wxMenu *) 0 ;
32346 size_t arg2 ;
32347 wxMenuItem *result;
32348 PyObject * obj0 = 0 ;
32349 PyObject * obj1 = 0 ;
32350 char *kwnames[] = {
32351 (char *) "self",(char *) "pos", NULL
32352 };
32353
32354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32356 if (SWIG_arg_fail(1)) SWIG_fail;
32357 {
32358 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32359 if (SWIG_arg_fail(2)) SWIG_fail;
32360 }
32361 {
32362 PyThreadState* __tstate = wxPyBeginAllowThreads();
32363 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
32364
32365 wxPyEndAllowThreads(__tstate);
32366 if (PyErr_Occurred()) SWIG_fail;
32367 }
32368 {
32369 resultobj = wxPyMake_wxObject(result, 0);
32370 }
32371 return resultobj;
32372 fail:
32373 return NULL;
32374 }
32375
32376
32377 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32378 PyObject *resultobj;
32379 wxMenu *arg1 = (wxMenu *) 0 ;
32380 size_t arg2 ;
32381 int arg3 ;
32382 wxString *arg4 = 0 ;
32383 wxString const &arg5_defvalue = wxPyEmptyString ;
32384 wxString *arg5 = (wxString *) &arg5_defvalue ;
32385 wxMenuItem *result;
32386 bool temp4 = false ;
32387 bool temp5 = false ;
32388 PyObject * obj0 = 0 ;
32389 PyObject * obj1 = 0 ;
32390 PyObject * obj2 = 0 ;
32391 PyObject * obj3 = 0 ;
32392 PyObject * obj4 = 0 ;
32393 char *kwnames[] = {
32394 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32395 };
32396
32397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32399 if (SWIG_arg_fail(1)) SWIG_fail;
32400 {
32401 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32402 if (SWIG_arg_fail(2)) SWIG_fail;
32403 }
32404 {
32405 arg3 = (int)(SWIG_As_int(obj2));
32406 if (SWIG_arg_fail(3)) SWIG_fail;
32407 }
32408 {
32409 arg4 = wxString_in_helper(obj3);
32410 if (arg4 == NULL) SWIG_fail;
32411 temp4 = true;
32412 }
32413 if (obj4) {
32414 {
32415 arg5 = wxString_in_helper(obj4);
32416 if (arg5 == NULL) SWIG_fail;
32417 temp5 = true;
32418 }
32419 }
32420 {
32421 PyThreadState* __tstate = wxPyBeginAllowThreads();
32422 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32423
32424 wxPyEndAllowThreads(__tstate);
32425 if (PyErr_Occurred()) SWIG_fail;
32426 }
32427 {
32428 resultobj = wxPyMake_wxObject(result, 0);
32429 }
32430 {
32431 if (temp4)
32432 delete arg4;
32433 }
32434 {
32435 if (temp5)
32436 delete arg5;
32437 }
32438 return resultobj;
32439 fail:
32440 {
32441 if (temp4)
32442 delete arg4;
32443 }
32444 {
32445 if (temp5)
32446 delete arg5;
32447 }
32448 return NULL;
32449 }
32450
32451
32452 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32453 PyObject *resultobj;
32454 wxMenu *arg1 = (wxMenu *) 0 ;
32455 size_t arg2 ;
32456 int arg3 ;
32457 wxString *arg4 = 0 ;
32458 wxString const &arg5_defvalue = wxPyEmptyString ;
32459 wxString *arg5 = (wxString *) &arg5_defvalue ;
32460 wxMenuItem *result;
32461 bool temp4 = false ;
32462 bool temp5 = false ;
32463 PyObject * obj0 = 0 ;
32464 PyObject * obj1 = 0 ;
32465 PyObject * obj2 = 0 ;
32466 PyObject * obj3 = 0 ;
32467 PyObject * obj4 = 0 ;
32468 char *kwnames[] = {
32469 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32470 };
32471
32472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32474 if (SWIG_arg_fail(1)) SWIG_fail;
32475 {
32476 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32477 if (SWIG_arg_fail(2)) SWIG_fail;
32478 }
32479 {
32480 arg3 = (int)(SWIG_As_int(obj2));
32481 if (SWIG_arg_fail(3)) SWIG_fail;
32482 }
32483 {
32484 arg4 = wxString_in_helper(obj3);
32485 if (arg4 == NULL) SWIG_fail;
32486 temp4 = true;
32487 }
32488 if (obj4) {
32489 {
32490 arg5 = wxString_in_helper(obj4);
32491 if (arg5 == NULL) SWIG_fail;
32492 temp5 = true;
32493 }
32494 }
32495 {
32496 PyThreadState* __tstate = wxPyBeginAllowThreads();
32497 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32498
32499 wxPyEndAllowThreads(__tstate);
32500 if (PyErr_Occurred()) SWIG_fail;
32501 }
32502 {
32503 resultobj = wxPyMake_wxObject(result, 0);
32504 }
32505 {
32506 if (temp4)
32507 delete arg4;
32508 }
32509 {
32510 if (temp5)
32511 delete arg5;
32512 }
32513 return resultobj;
32514 fail:
32515 {
32516 if (temp4)
32517 delete arg4;
32518 }
32519 {
32520 if (temp5)
32521 delete arg5;
32522 }
32523 return NULL;
32524 }
32525
32526
32527 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32528 PyObject *resultobj;
32529 wxMenu *arg1 = (wxMenu *) 0 ;
32530 size_t arg2 ;
32531 int arg3 ;
32532 wxString *arg4 = 0 ;
32533 wxMenu *arg5 = (wxMenu *) 0 ;
32534 wxString const &arg6_defvalue = wxPyEmptyString ;
32535 wxString *arg6 = (wxString *) &arg6_defvalue ;
32536 wxMenuItem *result;
32537 bool temp4 = false ;
32538 bool temp6 = false ;
32539 PyObject * obj0 = 0 ;
32540 PyObject * obj1 = 0 ;
32541 PyObject * obj2 = 0 ;
32542 PyObject * obj3 = 0 ;
32543 PyObject * obj4 = 0 ;
32544 PyObject * obj5 = 0 ;
32545 char *kwnames[] = {
32546 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32547 };
32548
32549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32551 if (SWIG_arg_fail(1)) SWIG_fail;
32552 {
32553 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32554 if (SWIG_arg_fail(2)) SWIG_fail;
32555 }
32556 {
32557 arg3 = (int)(SWIG_As_int(obj2));
32558 if (SWIG_arg_fail(3)) SWIG_fail;
32559 }
32560 {
32561 arg4 = wxString_in_helper(obj3);
32562 if (arg4 == NULL) SWIG_fail;
32563 temp4 = true;
32564 }
32565 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32566 if (SWIG_arg_fail(5)) SWIG_fail;
32567 if (obj5) {
32568 {
32569 arg6 = wxString_in_helper(obj5);
32570 if (arg6 == NULL) SWIG_fail;
32571 temp6 = true;
32572 }
32573 }
32574 {
32575 PyThreadState* __tstate = wxPyBeginAllowThreads();
32576 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
32577
32578 wxPyEndAllowThreads(__tstate);
32579 if (PyErr_Occurred()) SWIG_fail;
32580 }
32581 {
32582 resultobj = wxPyMake_wxObject(result, 0);
32583 }
32584 {
32585 if (temp4)
32586 delete arg4;
32587 }
32588 {
32589 if (temp6)
32590 delete arg6;
32591 }
32592 return resultobj;
32593 fail:
32594 {
32595 if (temp4)
32596 delete arg4;
32597 }
32598 {
32599 if (temp6)
32600 delete arg6;
32601 }
32602 return NULL;
32603 }
32604
32605
32606 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
32607 PyObject *resultobj;
32608 wxMenu *arg1 = (wxMenu *) 0 ;
32609 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32610 wxMenuItem *result;
32611 PyObject * obj0 = 0 ;
32612 PyObject * obj1 = 0 ;
32613 char *kwnames[] = {
32614 (char *) "self",(char *) "item", NULL
32615 };
32616
32617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
32618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32619 if (SWIG_arg_fail(1)) SWIG_fail;
32620 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32621 if (SWIG_arg_fail(2)) SWIG_fail;
32622 {
32623 PyThreadState* __tstate = wxPyBeginAllowThreads();
32624 result = (wxMenuItem *)(arg1)->Prepend(arg2);
32625
32626 wxPyEndAllowThreads(__tstate);
32627 if (PyErr_Occurred()) SWIG_fail;
32628 }
32629 {
32630 resultobj = wxPyMake_wxObject(result, 0);
32631 }
32632 return resultobj;
32633 fail:
32634 return NULL;
32635 }
32636
32637
32638 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
32639 PyObject *resultobj;
32640 wxMenu *arg1 = (wxMenu *) 0 ;
32641 int arg2 ;
32642 wxString *arg3 = 0 ;
32643 wxString const &arg4_defvalue = wxPyEmptyString ;
32644 wxString *arg4 = (wxString *) &arg4_defvalue ;
32645 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32646 wxMenuItem *result;
32647 bool temp3 = false ;
32648 bool temp4 = false ;
32649 PyObject * obj0 = 0 ;
32650 PyObject * obj1 = 0 ;
32651 PyObject * obj2 = 0 ;
32652 PyObject * obj3 = 0 ;
32653 PyObject * obj4 = 0 ;
32654 char *kwnames[] = {
32655 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32656 };
32657
32658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32660 if (SWIG_arg_fail(1)) SWIG_fail;
32661 {
32662 arg2 = (int)(SWIG_As_int(obj1));
32663 if (SWIG_arg_fail(2)) SWIG_fail;
32664 }
32665 {
32666 arg3 = wxString_in_helper(obj2);
32667 if (arg3 == NULL) SWIG_fail;
32668 temp3 = true;
32669 }
32670 if (obj3) {
32671 {
32672 arg4 = wxString_in_helper(obj3);
32673 if (arg4 == NULL) SWIG_fail;
32674 temp4 = true;
32675 }
32676 }
32677 if (obj4) {
32678 {
32679 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32680 if (SWIG_arg_fail(5)) SWIG_fail;
32681 }
32682 }
32683 {
32684 PyThreadState* __tstate = wxPyBeginAllowThreads();
32685 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32686
32687 wxPyEndAllowThreads(__tstate);
32688 if (PyErr_Occurred()) SWIG_fail;
32689 }
32690 {
32691 resultobj = wxPyMake_wxObject(result, 0);
32692 }
32693 {
32694 if (temp3)
32695 delete arg3;
32696 }
32697 {
32698 if (temp4)
32699 delete arg4;
32700 }
32701 return resultobj;
32702 fail:
32703 {
32704 if (temp3)
32705 delete arg3;
32706 }
32707 {
32708 if (temp4)
32709 delete arg4;
32710 }
32711 return NULL;
32712 }
32713
32714
32715 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32716 PyObject *resultobj;
32717 wxMenu *arg1 = (wxMenu *) 0 ;
32718 wxMenuItem *result;
32719 PyObject * obj0 = 0 ;
32720 char *kwnames[] = {
32721 (char *) "self", NULL
32722 };
32723
32724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
32725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32726 if (SWIG_arg_fail(1)) SWIG_fail;
32727 {
32728 PyThreadState* __tstate = wxPyBeginAllowThreads();
32729 result = (wxMenuItem *)(arg1)->PrependSeparator();
32730
32731 wxPyEndAllowThreads(__tstate);
32732 if (PyErr_Occurred()) SWIG_fail;
32733 }
32734 {
32735 resultobj = wxPyMake_wxObject(result, 0);
32736 }
32737 return resultobj;
32738 fail:
32739 return NULL;
32740 }
32741
32742
32743 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32744 PyObject *resultobj;
32745 wxMenu *arg1 = (wxMenu *) 0 ;
32746 int arg2 ;
32747 wxString *arg3 = 0 ;
32748 wxString const &arg4_defvalue = wxPyEmptyString ;
32749 wxString *arg4 = (wxString *) &arg4_defvalue ;
32750 wxMenuItem *result;
32751 bool temp3 = false ;
32752 bool temp4 = false ;
32753 PyObject * obj0 = 0 ;
32754 PyObject * obj1 = 0 ;
32755 PyObject * obj2 = 0 ;
32756 PyObject * obj3 = 0 ;
32757 char *kwnames[] = {
32758 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32759 };
32760
32761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32763 if (SWIG_arg_fail(1)) SWIG_fail;
32764 {
32765 arg2 = (int)(SWIG_As_int(obj1));
32766 if (SWIG_arg_fail(2)) SWIG_fail;
32767 }
32768 {
32769 arg3 = wxString_in_helper(obj2);
32770 if (arg3 == NULL) SWIG_fail;
32771 temp3 = true;
32772 }
32773 if (obj3) {
32774 {
32775 arg4 = wxString_in_helper(obj3);
32776 if (arg4 == NULL) SWIG_fail;
32777 temp4 = true;
32778 }
32779 }
32780 {
32781 PyThreadState* __tstate = wxPyBeginAllowThreads();
32782 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32783
32784 wxPyEndAllowThreads(__tstate);
32785 if (PyErr_Occurred()) SWIG_fail;
32786 }
32787 {
32788 resultobj = wxPyMake_wxObject(result, 0);
32789 }
32790 {
32791 if (temp3)
32792 delete arg3;
32793 }
32794 {
32795 if (temp4)
32796 delete arg4;
32797 }
32798 return resultobj;
32799 fail:
32800 {
32801 if (temp3)
32802 delete arg3;
32803 }
32804 {
32805 if (temp4)
32806 delete arg4;
32807 }
32808 return NULL;
32809 }
32810
32811
32812 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32813 PyObject *resultobj;
32814 wxMenu *arg1 = (wxMenu *) 0 ;
32815 int arg2 ;
32816 wxString *arg3 = 0 ;
32817 wxString const &arg4_defvalue = wxPyEmptyString ;
32818 wxString *arg4 = (wxString *) &arg4_defvalue ;
32819 wxMenuItem *result;
32820 bool temp3 = false ;
32821 bool temp4 = false ;
32822 PyObject * obj0 = 0 ;
32823 PyObject * obj1 = 0 ;
32824 PyObject * obj2 = 0 ;
32825 PyObject * obj3 = 0 ;
32826 char *kwnames[] = {
32827 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32828 };
32829
32830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32832 if (SWIG_arg_fail(1)) SWIG_fail;
32833 {
32834 arg2 = (int)(SWIG_As_int(obj1));
32835 if (SWIG_arg_fail(2)) SWIG_fail;
32836 }
32837 {
32838 arg3 = wxString_in_helper(obj2);
32839 if (arg3 == NULL) SWIG_fail;
32840 temp3 = true;
32841 }
32842 if (obj3) {
32843 {
32844 arg4 = wxString_in_helper(obj3);
32845 if (arg4 == NULL) SWIG_fail;
32846 temp4 = true;
32847 }
32848 }
32849 {
32850 PyThreadState* __tstate = wxPyBeginAllowThreads();
32851 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32852
32853 wxPyEndAllowThreads(__tstate);
32854 if (PyErr_Occurred()) SWIG_fail;
32855 }
32856 {
32857 resultobj = wxPyMake_wxObject(result, 0);
32858 }
32859 {
32860 if (temp3)
32861 delete arg3;
32862 }
32863 {
32864 if (temp4)
32865 delete arg4;
32866 }
32867 return resultobj;
32868 fail:
32869 {
32870 if (temp3)
32871 delete arg3;
32872 }
32873 {
32874 if (temp4)
32875 delete arg4;
32876 }
32877 return NULL;
32878 }
32879
32880
32881 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32882 PyObject *resultobj;
32883 wxMenu *arg1 = (wxMenu *) 0 ;
32884 int arg2 ;
32885 wxString *arg3 = 0 ;
32886 wxMenu *arg4 = (wxMenu *) 0 ;
32887 wxString const &arg5_defvalue = wxPyEmptyString ;
32888 wxString *arg5 = (wxString *) &arg5_defvalue ;
32889 wxMenuItem *result;
32890 bool temp3 = false ;
32891 bool temp5 = false ;
32892 PyObject * obj0 = 0 ;
32893 PyObject * obj1 = 0 ;
32894 PyObject * obj2 = 0 ;
32895 PyObject * obj3 = 0 ;
32896 PyObject * obj4 = 0 ;
32897 char *kwnames[] = {
32898 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32899 };
32900
32901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32903 if (SWIG_arg_fail(1)) SWIG_fail;
32904 {
32905 arg2 = (int)(SWIG_As_int(obj1));
32906 if (SWIG_arg_fail(2)) SWIG_fail;
32907 }
32908 {
32909 arg3 = wxString_in_helper(obj2);
32910 if (arg3 == NULL) SWIG_fail;
32911 temp3 = true;
32912 }
32913 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32914 if (SWIG_arg_fail(4)) SWIG_fail;
32915 if (obj4) {
32916 {
32917 arg5 = wxString_in_helper(obj4);
32918 if (arg5 == NULL) SWIG_fail;
32919 temp5 = true;
32920 }
32921 }
32922 {
32923 PyThreadState* __tstate = wxPyBeginAllowThreads();
32924 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32925
32926 wxPyEndAllowThreads(__tstate);
32927 if (PyErr_Occurred()) SWIG_fail;
32928 }
32929 {
32930 resultobj = wxPyMake_wxObject(result, 0);
32931 }
32932 {
32933 if (temp3)
32934 delete arg3;
32935 }
32936 {
32937 if (temp5)
32938 delete arg5;
32939 }
32940 return resultobj;
32941 fail:
32942 {
32943 if (temp3)
32944 delete arg3;
32945 }
32946 {
32947 if (temp5)
32948 delete arg5;
32949 }
32950 return NULL;
32951 }
32952
32953
32954 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
32955 PyObject *resultobj;
32956 wxMenu *arg1 = (wxMenu *) 0 ;
32957 int arg2 ;
32958 wxMenuItem *result;
32959 PyObject * obj0 = 0 ;
32960 PyObject * obj1 = 0 ;
32961 char *kwnames[] = {
32962 (char *) "self",(char *) "id", NULL
32963 };
32964
32965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
32966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32967 if (SWIG_arg_fail(1)) SWIG_fail;
32968 {
32969 arg2 = (int)(SWIG_As_int(obj1));
32970 if (SWIG_arg_fail(2)) SWIG_fail;
32971 }
32972 {
32973 PyThreadState* __tstate = wxPyBeginAllowThreads();
32974 result = (wxMenuItem *)(arg1)->Remove(arg2);
32975
32976 wxPyEndAllowThreads(__tstate);
32977 if (PyErr_Occurred()) SWIG_fail;
32978 }
32979 {
32980 resultobj = wxPyMake_wxObject(result, 0);
32981 }
32982 return resultobj;
32983 fail:
32984 return NULL;
32985 }
32986
32987
32988 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
32989 PyObject *resultobj;
32990 wxMenu *arg1 = (wxMenu *) 0 ;
32991 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32992 wxMenuItem *result;
32993 PyObject * obj0 = 0 ;
32994 PyObject * obj1 = 0 ;
32995 char *kwnames[] = {
32996 (char *) "self",(char *) "item", NULL
32997 };
32998
32999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33001 if (SWIG_arg_fail(1)) SWIG_fail;
33002 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33003 if (SWIG_arg_fail(2)) SWIG_fail;
33004 {
33005 PyThreadState* __tstate = wxPyBeginAllowThreads();
33006 result = (wxMenuItem *)(arg1)->Remove(arg2);
33007
33008 wxPyEndAllowThreads(__tstate);
33009 if (PyErr_Occurred()) SWIG_fail;
33010 }
33011 {
33012 resultobj = wxPyMake_wxObject(result, 0);
33013 }
33014 return resultobj;
33015 fail:
33016 return NULL;
33017 }
33018
33019
33020 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33021 PyObject *resultobj;
33022 wxMenu *arg1 = (wxMenu *) 0 ;
33023 int arg2 ;
33024 bool result;
33025 PyObject * obj0 = 0 ;
33026 PyObject * obj1 = 0 ;
33027 char *kwnames[] = {
33028 (char *) "self",(char *) "id", NULL
33029 };
33030
33031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33033 if (SWIG_arg_fail(1)) SWIG_fail;
33034 {
33035 arg2 = (int)(SWIG_As_int(obj1));
33036 if (SWIG_arg_fail(2)) SWIG_fail;
33037 }
33038 {
33039 PyThreadState* __tstate = wxPyBeginAllowThreads();
33040 result = (bool)(arg1)->Delete(arg2);
33041
33042 wxPyEndAllowThreads(__tstate);
33043 if (PyErr_Occurred()) SWIG_fail;
33044 }
33045 {
33046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33047 }
33048 return resultobj;
33049 fail:
33050 return NULL;
33051 }
33052
33053
33054 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33055 PyObject *resultobj;
33056 wxMenu *arg1 = (wxMenu *) 0 ;
33057 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33058 bool result;
33059 PyObject * obj0 = 0 ;
33060 PyObject * obj1 = 0 ;
33061 char *kwnames[] = {
33062 (char *) "self",(char *) "item", NULL
33063 };
33064
33065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33067 if (SWIG_arg_fail(1)) SWIG_fail;
33068 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33069 if (SWIG_arg_fail(2)) SWIG_fail;
33070 {
33071 PyThreadState* __tstate = wxPyBeginAllowThreads();
33072 result = (bool)(arg1)->Delete(arg2);
33073
33074 wxPyEndAllowThreads(__tstate);
33075 if (PyErr_Occurred()) SWIG_fail;
33076 }
33077 {
33078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33079 }
33080 return resultobj;
33081 fail:
33082 return NULL;
33083 }
33084
33085
33086 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33087 PyObject *resultobj;
33088 wxMenu *arg1 = (wxMenu *) 0 ;
33089 PyObject * obj0 = 0 ;
33090 char *kwnames[] = {
33091 (char *) "self", NULL
33092 };
33093
33094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33096 if (SWIG_arg_fail(1)) SWIG_fail;
33097 {
33098 PyThreadState* __tstate = wxPyBeginAllowThreads();
33099 wxMenu_Destroy(arg1);
33100
33101 wxPyEndAllowThreads(__tstate);
33102 if (PyErr_Occurred()) SWIG_fail;
33103 }
33104 Py_INCREF(Py_None); resultobj = Py_None;
33105 return resultobj;
33106 fail:
33107 return NULL;
33108 }
33109
33110
33111 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33112 PyObject *resultobj;
33113 wxMenu *arg1 = (wxMenu *) 0 ;
33114 int arg2 ;
33115 bool result;
33116 PyObject * obj0 = 0 ;
33117 PyObject * obj1 = 0 ;
33118 char *kwnames[] = {
33119 (char *) "self",(char *) "id", NULL
33120 };
33121
33122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33124 if (SWIG_arg_fail(1)) SWIG_fail;
33125 {
33126 arg2 = (int)(SWIG_As_int(obj1));
33127 if (SWIG_arg_fail(2)) SWIG_fail;
33128 }
33129 {
33130 PyThreadState* __tstate = wxPyBeginAllowThreads();
33131 result = (bool)(arg1)->Destroy(arg2);
33132
33133 wxPyEndAllowThreads(__tstate);
33134 if (PyErr_Occurred()) SWIG_fail;
33135 }
33136 {
33137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33138 }
33139 return resultobj;
33140 fail:
33141 return NULL;
33142 }
33143
33144
33145 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33146 PyObject *resultobj;
33147 wxMenu *arg1 = (wxMenu *) 0 ;
33148 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33149 bool result;
33150 PyObject * obj0 = 0 ;
33151 PyObject * obj1 = 0 ;
33152 char *kwnames[] = {
33153 (char *) "self",(char *) "item", NULL
33154 };
33155
33156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33158 if (SWIG_arg_fail(1)) SWIG_fail;
33159 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33160 if (SWIG_arg_fail(2)) SWIG_fail;
33161 {
33162 PyThreadState* __tstate = wxPyBeginAllowThreads();
33163 result = (bool)(arg1)->Destroy(arg2);
33164
33165 wxPyEndAllowThreads(__tstate);
33166 if (PyErr_Occurred()) SWIG_fail;
33167 }
33168 {
33169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33170 }
33171 return resultobj;
33172 fail:
33173 return NULL;
33174 }
33175
33176
33177 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33178 PyObject *resultobj;
33179 wxMenu *arg1 = (wxMenu *) 0 ;
33180 size_t result;
33181 PyObject * obj0 = 0 ;
33182 char *kwnames[] = {
33183 (char *) "self", NULL
33184 };
33185
33186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33188 if (SWIG_arg_fail(1)) SWIG_fail;
33189 {
33190 PyThreadState* __tstate = wxPyBeginAllowThreads();
33191 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33192
33193 wxPyEndAllowThreads(__tstate);
33194 if (PyErr_Occurred()) SWIG_fail;
33195 }
33196 {
33197 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33198 }
33199 return resultobj;
33200 fail:
33201 return NULL;
33202 }
33203
33204
33205 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33206 PyObject *resultobj;
33207 wxMenu *arg1 = (wxMenu *) 0 ;
33208 PyObject *result;
33209 PyObject * obj0 = 0 ;
33210 char *kwnames[] = {
33211 (char *) "self", NULL
33212 };
33213
33214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33216 if (SWIG_arg_fail(1)) SWIG_fail;
33217 {
33218 PyThreadState* __tstate = wxPyBeginAllowThreads();
33219 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33220
33221 wxPyEndAllowThreads(__tstate);
33222 if (PyErr_Occurred()) SWIG_fail;
33223 }
33224 resultobj = result;
33225 return resultobj;
33226 fail:
33227 return NULL;
33228 }
33229
33230
33231 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33232 PyObject *resultobj;
33233 wxMenu *arg1 = (wxMenu *) 0 ;
33234 wxString *arg2 = 0 ;
33235 int result;
33236 bool temp2 = false ;
33237 PyObject * obj0 = 0 ;
33238 PyObject * obj1 = 0 ;
33239 char *kwnames[] = {
33240 (char *) "self",(char *) "item", NULL
33241 };
33242
33243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33245 if (SWIG_arg_fail(1)) SWIG_fail;
33246 {
33247 arg2 = wxString_in_helper(obj1);
33248 if (arg2 == NULL) SWIG_fail;
33249 temp2 = true;
33250 }
33251 {
33252 PyThreadState* __tstate = wxPyBeginAllowThreads();
33253 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33254
33255 wxPyEndAllowThreads(__tstate);
33256 if (PyErr_Occurred()) SWIG_fail;
33257 }
33258 {
33259 resultobj = SWIG_From_int((int)(result));
33260 }
33261 {
33262 if (temp2)
33263 delete arg2;
33264 }
33265 return resultobj;
33266 fail:
33267 {
33268 if (temp2)
33269 delete arg2;
33270 }
33271 return NULL;
33272 }
33273
33274
33275 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33276 PyObject *resultobj;
33277 wxMenu *arg1 = (wxMenu *) 0 ;
33278 int arg2 ;
33279 wxMenuItem *result;
33280 PyObject * obj0 = 0 ;
33281 PyObject * obj1 = 0 ;
33282 char *kwnames[] = {
33283 (char *) "self",(char *) "id", NULL
33284 };
33285
33286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) 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 = (int)(SWIG_As_int(obj1));
33291 if (SWIG_arg_fail(2)) SWIG_fail;
33292 }
33293 {
33294 PyThreadState* __tstate = wxPyBeginAllowThreads();
33295 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33296
33297 wxPyEndAllowThreads(__tstate);
33298 if (PyErr_Occurred()) SWIG_fail;
33299 }
33300 {
33301 resultobj = wxPyMake_wxObject(result, 0);
33302 }
33303 return resultobj;
33304 fail:
33305 return NULL;
33306 }
33307
33308
33309 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33310 PyObject *resultobj;
33311 wxMenu *arg1 = (wxMenu *) 0 ;
33312 size_t arg2 ;
33313 wxMenuItem *result;
33314 PyObject * obj0 = 0 ;
33315 PyObject * obj1 = 0 ;
33316 char *kwnames[] = {
33317 (char *) "self",(char *) "position", NULL
33318 };
33319
33320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33322 if (SWIG_arg_fail(1)) SWIG_fail;
33323 {
33324 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33325 if (SWIG_arg_fail(2)) SWIG_fail;
33326 }
33327 {
33328 PyThreadState* __tstate = wxPyBeginAllowThreads();
33329 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33330
33331 wxPyEndAllowThreads(__tstate);
33332 if (PyErr_Occurred()) SWIG_fail;
33333 }
33334 {
33335 resultobj = wxPyMake_wxObject(result, 0);
33336 }
33337 return resultobj;
33338 fail:
33339 return NULL;
33340 }
33341
33342
33343 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33344 PyObject *resultobj;
33345 wxMenu *arg1 = (wxMenu *) 0 ;
33346 int arg2 ;
33347 bool arg3 ;
33348 PyObject * obj0 = 0 ;
33349 PyObject * obj1 = 0 ;
33350 PyObject * obj2 = 0 ;
33351 char *kwnames[] = {
33352 (char *) "self",(char *) "id",(char *) "enable", NULL
33353 };
33354
33355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33357 if (SWIG_arg_fail(1)) SWIG_fail;
33358 {
33359 arg2 = (int)(SWIG_As_int(obj1));
33360 if (SWIG_arg_fail(2)) SWIG_fail;
33361 }
33362 {
33363 arg3 = (bool)(SWIG_As_bool(obj2));
33364 if (SWIG_arg_fail(3)) SWIG_fail;
33365 }
33366 {
33367 PyThreadState* __tstate = wxPyBeginAllowThreads();
33368 (arg1)->Enable(arg2,arg3);
33369
33370 wxPyEndAllowThreads(__tstate);
33371 if (PyErr_Occurred()) SWIG_fail;
33372 }
33373 Py_INCREF(Py_None); resultobj = Py_None;
33374 return resultobj;
33375 fail:
33376 return NULL;
33377 }
33378
33379
33380 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
33381 PyObject *resultobj;
33382 wxMenu *arg1 = (wxMenu *) 0 ;
33383 int arg2 ;
33384 bool result;
33385 PyObject * obj0 = 0 ;
33386 PyObject * obj1 = 0 ;
33387 char *kwnames[] = {
33388 (char *) "self",(char *) "id", NULL
33389 };
33390
33391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
33392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33393 if (SWIG_arg_fail(1)) SWIG_fail;
33394 {
33395 arg2 = (int)(SWIG_As_int(obj1));
33396 if (SWIG_arg_fail(2)) SWIG_fail;
33397 }
33398 {
33399 PyThreadState* __tstate = wxPyBeginAllowThreads();
33400 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
33401
33402 wxPyEndAllowThreads(__tstate);
33403 if (PyErr_Occurred()) SWIG_fail;
33404 }
33405 {
33406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33407 }
33408 return resultobj;
33409 fail:
33410 return NULL;
33411 }
33412
33413
33414 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
33415 PyObject *resultobj;
33416 wxMenu *arg1 = (wxMenu *) 0 ;
33417 int arg2 ;
33418 bool arg3 ;
33419 PyObject * obj0 = 0 ;
33420 PyObject * obj1 = 0 ;
33421 PyObject * obj2 = 0 ;
33422 char *kwnames[] = {
33423 (char *) "self",(char *) "id",(char *) "check", NULL
33424 };
33425
33426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
33427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33428 if (SWIG_arg_fail(1)) SWIG_fail;
33429 {
33430 arg2 = (int)(SWIG_As_int(obj1));
33431 if (SWIG_arg_fail(2)) SWIG_fail;
33432 }
33433 {
33434 arg3 = (bool)(SWIG_As_bool(obj2));
33435 if (SWIG_arg_fail(3)) SWIG_fail;
33436 }
33437 {
33438 PyThreadState* __tstate = wxPyBeginAllowThreads();
33439 (arg1)->Check(arg2,arg3);
33440
33441 wxPyEndAllowThreads(__tstate);
33442 if (PyErr_Occurred()) SWIG_fail;
33443 }
33444 Py_INCREF(Py_None); resultobj = Py_None;
33445 return resultobj;
33446 fail:
33447 return NULL;
33448 }
33449
33450
33451 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
33452 PyObject *resultobj;
33453 wxMenu *arg1 = (wxMenu *) 0 ;
33454 int arg2 ;
33455 bool result;
33456 PyObject * obj0 = 0 ;
33457 PyObject * obj1 = 0 ;
33458 char *kwnames[] = {
33459 (char *) "self",(char *) "id", NULL
33460 };
33461
33462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
33463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33464 if (SWIG_arg_fail(1)) SWIG_fail;
33465 {
33466 arg2 = (int)(SWIG_As_int(obj1));
33467 if (SWIG_arg_fail(2)) SWIG_fail;
33468 }
33469 {
33470 PyThreadState* __tstate = wxPyBeginAllowThreads();
33471 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
33472
33473 wxPyEndAllowThreads(__tstate);
33474 if (PyErr_Occurred()) SWIG_fail;
33475 }
33476 {
33477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33478 }
33479 return resultobj;
33480 fail:
33481 return NULL;
33482 }
33483
33484
33485 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33486 PyObject *resultobj;
33487 wxMenu *arg1 = (wxMenu *) 0 ;
33488 int arg2 ;
33489 wxString *arg3 = 0 ;
33490 bool temp3 = false ;
33491 PyObject * obj0 = 0 ;
33492 PyObject * obj1 = 0 ;
33493 PyObject * obj2 = 0 ;
33494 char *kwnames[] = {
33495 (char *) "self",(char *) "id",(char *) "label", NULL
33496 };
33497
33498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) 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 {
33511 PyThreadState* __tstate = wxPyBeginAllowThreads();
33512 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
33513
33514 wxPyEndAllowThreads(__tstate);
33515 if (PyErr_Occurred()) SWIG_fail;
33516 }
33517 Py_INCREF(Py_None); resultobj = Py_None;
33518 {
33519 if (temp3)
33520 delete arg3;
33521 }
33522 return resultobj;
33523 fail:
33524 {
33525 if (temp3)
33526 delete arg3;
33527 }
33528 return NULL;
33529 }
33530
33531
33532 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33533 PyObject *resultobj;
33534 wxMenu *arg1 = (wxMenu *) 0 ;
33535 int arg2 ;
33536 wxString result;
33537 PyObject * obj0 = 0 ;
33538 PyObject * obj1 = 0 ;
33539 char *kwnames[] = {
33540 (char *) "self",(char *) "id", NULL
33541 };
33542
33543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
33544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33545 if (SWIG_arg_fail(1)) SWIG_fail;
33546 {
33547 arg2 = (int)(SWIG_As_int(obj1));
33548 if (SWIG_arg_fail(2)) SWIG_fail;
33549 }
33550 {
33551 PyThreadState* __tstate = wxPyBeginAllowThreads();
33552 result = ((wxMenu const *)arg1)->GetLabel(arg2);
33553
33554 wxPyEndAllowThreads(__tstate);
33555 if (PyErr_Occurred()) SWIG_fail;
33556 }
33557 {
33558 #if wxUSE_UNICODE
33559 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33560 #else
33561 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33562 #endif
33563 }
33564 return resultobj;
33565 fail:
33566 return NULL;
33567 }
33568
33569
33570 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33571 PyObject *resultobj;
33572 wxMenu *arg1 = (wxMenu *) 0 ;
33573 int arg2 ;
33574 wxString *arg3 = 0 ;
33575 bool temp3 = false ;
33576 PyObject * obj0 = 0 ;
33577 PyObject * obj1 = 0 ;
33578 PyObject * obj2 = 0 ;
33579 char *kwnames[] = {
33580 (char *) "self",(char *) "id",(char *) "helpString", NULL
33581 };
33582
33583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
33584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33585 if (SWIG_arg_fail(1)) SWIG_fail;
33586 {
33587 arg2 = (int)(SWIG_As_int(obj1));
33588 if (SWIG_arg_fail(2)) SWIG_fail;
33589 }
33590 {
33591 arg3 = wxString_in_helper(obj2);
33592 if (arg3 == NULL) SWIG_fail;
33593 temp3 = true;
33594 }
33595 {
33596 PyThreadState* __tstate = wxPyBeginAllowThreads();
33597 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
33598
33599 wxPyEndAllowThreads(__tstate);
33600 if (PyErr_Occurred()) SWIG_fail;
33601 }
33602 Py_INCREF(Py_None); resultobj = Py_None;
33603 {
33604 if (temp3)
33605 delete arg3;
33606 }
33607 return resultobj;
33608 fail:
33609 {
33610 if (temp3)
33611 delete arg3;
33612 }
33613 return NULL;
33614 }
33615
33616
33617 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33618 PyObject *resultobj;
33619 wxMenu *arg1 = (wxMenu *) 0 ;
33620 int arg2 ;
33621 wxString result;
33622 PyObject * obj0 = 0 ;
33623 PyObject * obj1 = 0 ;
33624 char *kwnames[] = {
33625 (char *) "self",(char *) "id", NULL
33626 };
33627
33628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
33629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33630 if (SWIG_arg_fail(1)) SWIG_fail;
33631 {
33632 arg2 = (int)(SWIG_As_int(obj1));
33633 if (SWIG_arg_fail(2)) SWIG_fail;
33634 }
33635 {
33636 PyThreadState* __tstate = wxPyBeginAllowThreads();
33637 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
33638
33639 wxPyEndAllowThreads(__tstate);
33640 if (PyErr_Occurred()) SWIG_fail;
33641 }
33642 {
33643 #if wxUSE_UNICODE
33644 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33645 #else
33646 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33647 #endif
33648 }
33649 return resultobj;
33650 fail:
33651 return NULL;
33652 }
33653
33654
33655 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33656 PyObject *resultobj;
33657 wxMenu *arg1 = (wxMenu *) 0 ;
33658 wxString *arg2 = 0 ;
33659 bool temp2 = false ;
33660 PyObject * obj0 = 0 ;
33661 PyObject * obj1 = 0 ;
33662 char *kwnames[] = {
33663 (char *) "self",(char *) "title", NULL
33664 };
33665
33666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
33667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33668 if (SWIG_arg_fail(1)) SWIG_fail;
33669 {
33670 arg2 = wxString_in_helper(obj1);
33671 if (arg2 == NULL) SWIG_fail;
33672 temp2 = true;
33673 }
33674 {
33675 PyThreadState* __tstate = wxPyBeginAllowThreads();
33676 (arg1)->SetTitle((wxString const &)*arg2);
33677
33678 wxPyEndAllowThreads(__tstate);
33679 if (PyErr_Occurred()) SWIG_fail;
33680 }
33681 Py_INCREF(Py_None); resultobj = Py_None;
33682 {
33683 if (temp2)
33684 delete arg2;
33685 }
33686 return resultobj;
33687 fail:
33688 {
33689 if (temp2)
33690 delete arg2;
33691 }
33692 return NULL;
33693 }
33694
33695
33696 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33697 PyObject *resultobj;
33698 wxMenu *arg1 = (wxMenu *) 0 ;
33699 wxString result;
33700 PyObject * obj0 = 0 ;
33701 char *kwnames[] = {
33702 (char *) "self", NULL
33703 };
33704
33705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
33706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33707 if (SWIG_arg_fail(1)) SWIG_fail;
33708 {
33709 PyThreadState* __tstate = wxPyBeginAllowThreads();
33710 result = ((wxMenu const *)arg1)->GetTitle();
33711
33712 wxPyEndAllowThreads(__tstate);
33713 if (PyErr_Occurred()) SWIG_fail;
33714 }
33715 {
33716 #if wxUSE_UNICODE
33717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33718 #else
33719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33720 #endif
33721 }
33722 return resultobj;
33723 fail:
33724 return NULL;
33725 }
33726
33727
33728 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33729 PyObject *resultobj;
33730 wxMenu *arg1 = (wxMenu *) 0 ;
33731 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33732 PyObject * obj0 = 0 ;
33733 PyObject * obj1 = 0 ;
33734 char *kwnames[] = {
33735 (char *) "self",(char *) "handler", NULL
33736 };
33737
33738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
33739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33740 if (SWIG_arg_fail(1)) SWIG_fail;
33741 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
33742 if (SWIG_arg_fail(2)) SWIG_fail;
33743 {
33744 PyThreadState* __tstate = wxPyBeginAllowThreads();
33745 (arg1)->SetEventHandler(arg2);
33746
33747 wxPyEndAllowThreads(__tstate);
33748 if (PyErr_Occurred()) SWIG_fail;
33749 }
33750 Py_INCREF(Py_None); resultobj = Py_None;
33751 return resultobj;
33752 fail:
33753 return NULL;
33754 }
33755
33756
33757 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33758 PyObject *resultobj;
33759 wxMenu *arg1 = (wxMenu *) 0 ;
33760 wxEvtHandler *result;
33761 PyObject * obj0 = 0 ;
33762 char *kwnames[] = {
33763 (char *) "self", NULL
33764 };
33765
33766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
33767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33768 if (SWIG_arg_fail(1)) SWIG_fail;
33769 {
33770 PyThreadState* __tstate = wxPyBeginAllowThreads();
33771 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
33772
33773 wxPyEndAllowThreads(__tstate);
33774 if (PyErr_Occurred()) SWIG_fail;
33775 }
33776 {
33777 resultobj = wxPyMake_wxObject(result, 0);
33778 }
33779 return resultobj;
33780 fail:
33781 return NULL;
33782 }
33783
33784
33785 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33786 PyObject *resultobj;
33787 wxMenu *arg1 = (wxMenu *) 0 ;
33788 wxWindow *arg2 = (wxWindow *) 0 ;
33789 PyObject * obj0 = 0 ;
33790 PyObject * obj1 = 0 ;
33791 char *kwnames[] = {
33792 (char *) "self",(char *) "win", NULL
33793 };
33794
33795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
33796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33797 if (SWIG_arg_fail(1)) SWIG_fail;
33798 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33799 if (SWIG_arg_fail(2)) SWIG_fail;
33800 {
33801 PyThreadState* __tstate = wxPyBeginAllowThreads();
33802 (arg1)->SetInvokingWindow(arg2);
33803
33804 wxPyEndAllowThreads(__tstate);
33805 if (PyErr_Occurred()) SWIG_fail;
33806 }
33807 Py_INCREF(Py_None); resultobj = Py_None;
33808 return resultobj;
33809 fail:
33810 return NULL;
33811 }
33812
33813
33814 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33815 PyObject *resultobj;
33816 wxMenu *arg1 = (wxMenu *) 0 ;
33817 wxWindow *result;
33818 PyObject * obj0 = 0 ;
33819 char *kwnames[] = {
33820 (char *) "self", NULL
33821 };
33822
33823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
33824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33825 if (SWIG_arg_fail(1)) SWIG_fail;
33826 {
33827 PyThreadState* __tstate = wxPyBeginAllowThreads();
33828 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
33829
33830 wxPyEndAllowThreads(__tstate);
33831 if (PyErr_Occurred()) SWIG_fail;
33832 }
33833 {
33834 resultobj = wxPyMake_wxObject(result, 0);
33835 }
33836 return resultobj;
33837 fail:
33838 return NULL;
33839 }
33840
33841
33842 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
33843 PyObject *resultobj;
33844 wxMenu *arg1 = (wxMenu *) 0 ;
33845 long result;
33846 PyObject * obj0 = 0 ;
33847 char *kwnames[] = {
33848 (char *) "self", NULL
33849 };
33850
33851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
33852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33853 if (SWIG_arg_fail(1)) SWIG_fail;
33854 {
33855 PyThreadState* __tstate = wxPyBeginAllowThreads();
33856 result = (long)((wxMenu const *)arg1)->GetStyle();
33857
33858 wxPyEndAllowThreads(__tstate);
33859 if (PyErr_Occurred()) SWIG_fail;
33860 }
33861 {
33862 resultobj = SWIG_From_long((long)(result));
33863 }
33864 return resultobj;
33865 fail:
33866 return NULL;
33867 }
33868
33869
33870 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
33871 PyObject *resultobj;
33872 wxMenu *arg1 = (wxMenu *) 0 ;
33873 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
33874 PyObject * obj0 = 0 ;
33875 PyObject * obj1 = 0 ;
33876 char *kwnames[] = {
33877 (char *) "self",(char *) "source", NULL
33878 };
33879
33880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
33881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33882 if (SWIG_arg_fail(1)) SWIG_fail;
33883 if (obj1) {
33884 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
33885 if (SWIG_arg_fail(2)) SWIG_fail;
33886 }
33887 {
33888 PyThreadState* __tstate = wxPyBeginAllowThreads();
33889 (arg1)->UpdateUI(arg2);
33890
33891 wxPyEndAllowThreads(__tstate);
33892 if (PyErr_Occurred()) SWIG_fail;
33893 }
33894 Py_INCREF(Py_None); resultobj = Py_None;
33895 return resultobj;
33896 fail:
33897 return NULL;
33898 }
33899
33900
33901 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
33902 PyObject *resultobj;
33903 wxMenu *arg1 = (wxMenu *) 0 ;
33904 wxMenuBar *result;
33905 PyObject * obj0 = 0 ;
33906 char *kwnames[] = {
33907 (char *) "self", NULL
33908 };
33909
33910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
33911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33912 if (SWIG_arg_fail(1)) SWIG_fail;
33913 {
33914 PyThreadState* __tstate = wxPyBeginAllowThreads();
33915 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
33916
33917 wxPyEndAllowThreads(__tstate);
33918 if (PyErr_Occurred()) SWIG_fail;
33919 }
33920 {
33921 resultobj = wxPyMake_wxObject(result, 0);
33922 }
33923 return resultobj;
33924 fail:
33925 return NULL;
33926 }
33927
33928
33929 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
33930 PyObject *resultobj;
33931 wxMenu *arg1 = (wxMenu *) 0 ;
33932 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
33933 PyObject * obj0 = 0 ;
33934 PyObject * obj1 = 0 ;
33935 char *kwnames[] = {
33936 (char *) "self",(char *) "menubar", NULL
33937 };
33938
33939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
33940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33941 if (SWIG_arg_fail(1)) SWIG_fail;
33942 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
33943 if (SWIG_arg_fail(2)) SWIG_fail;
33944 {
33945 PyThreadState* __tstate = wxPyBeginAllowThreads();
33946 (arg1)->Attach(arg2);
33947
33948 wxPyEndAllowThreads(__tstate);
33949 if (PyErr_Occurred()) SWIG_fail;
33950 }
33951 Py_INCREF(Py_None); resultobj = Py_None;
33952 return resultobj;
33953 fail:
33954 return NULL;
33955 }
33956
33957
33958 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
33959 PyObject *resultobj;
33960 wxMenu *arg1 = (wxMenu *) 0 ;
33961 PyObject * obj0 = 0 ;
33962 char *kwnames[] = {
33963 (char *) "self", NULL
33964 };
33965
33966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
33967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33968 if (SWIG_arg_fail(1)) SWIG_fail;
33969 {
33970 PyThreadState* __tstate = wxPyBeginAllowThreads();
33971 (arg1)->Detach();
33972
33973 wxPyEndAllowThreads(__tstate);
33974 if (PyErr_Occurred()) SWIG_fail;
33975 }
33976 Py_INCREF(Py_None); resultobj = Py_None;
33977 return resultobj;
33978 fail:
33979 return NULL;
33980 }
33981
33982
33983 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
33984 PyObject *resultobj;
33985 wxMenu *arg1 = (wxMenu *) 0 ;
33986 bool result;
33987 PyObject * obj0 = 0 ;
33988 char *kwnames[] = {
33989 (char *) "self", NULL
33990 };
33991
33992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
33993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33994 if (SWIG_arg_fail(1)) SWIG_fail;
33995 {
33996 PyThreadState* __tstate = wxPyBeginAllowThreads();
33997 result = (bool)((wxMenu const *)arg1)->IsAttached();
33998
33999 wxPyEndAllowThreads(__tstate);
34000 if (PyErr_Occurred()) SWIG_fail;
34001 }
34002 {
34003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34004 }
34005 return resultobj;
34006 fail:
34007 return NULL;
34008 }
34009
34010
34011 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34012 PyObject *resultobj;
34013 wxMenu *arg1 = (wxMenu *) 0 ;
34014 wxMenu *arg2 = (wxMenu *) 0 ;
34015 PyObject * obj0 = 0 ;
34016 PyObject * obj1 = 0 ;
34017 char *kwnames[] = {
34018 (char *) "self",(char *) "parent", NULL
34019 };
34020
34021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34023 if (SWIG_arg_fail(1)) SWIG_fail;
34024 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34025 if (SWIG_arg_fail(2)) SWIG_fail;
34026 {
34027 PyThreadState* __tstate = wxPyBeginAllowThreads();
34028 (arg1)->SetParent(arg2);
34029
34030 wxPyEndAllowThreads(__tstate);
34031 if (PyErr_Occurred()) SWIG_fail;
34032 }
34033 Py_INCREF(Py_None); resultobj = Py_None;
34034 return resultobj;
34035 fail:
34036 return NULL;
34037 }
34038
34039
34040 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34041 PyObject *resultobj;
34042 wxMenu *arg1 = (wxMenu *) 0 ;
34043 wxMenu *result;
34044 PyObject * obj0 = 0 ;
34045 char *kwnames[] = {
34046 (char *) "self", NULL
34047 };
34048
34049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34051 if (SWIG_arg_fail(1)) SWIG_fail;
34052 {
34053 PyThreadState* __tstate = wxPyBeginAllowThreads();
34054 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34055
34056 wxPyEndAllowThreads(__tstate);
34057 if (PyErr_Occurred()) SWIG_fail;
34058 }
34059 {
34060 resultobj = wxPyMake_wxObject(result, 0);
34061 }
34062 return resultobj;
34063 fail:
34064 return NULL;
34065 }
34066
34067
34068 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34069 PyObject *obj;
34070 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34071 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34072 Py_INCREF(obj);
34073 return Py_BuildValue((char *)"");
34074 }
34075 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34076 PyObject *resultobj;
34077 long arg1 = (long) 0 ;
34078 wxMenuBar *result;
34079 PyObject * obj0 = 0 ;
34080 char *kwnames[] = {
34081 (char *) "style", NULL
34082 };
34083
34084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34085 if (obj0) {
34086 {
34087 arg1 = (long)(SWIG_As_long(obj0));
34088 if (SWIG_arg_fail(1)) SWIG_fail;
34089 }
34090 }
34091 {
34092 if (!wxPyCheckForApp()) SWIG_fail;
34093 PyThreadState* __tstate = wxPyBeginAllowThreads();
34094 result = (wxMenuBar *)new wxMenuBar(arg1);
34095
34096 wxPyEndAllowThreads(__tstate);
34097 if (PyErr_Occurred()) SWIG_fail;
34098 }
34099 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34100 return resultobj;
34101 fail:
34102 return NULL;
34103 }
34104
34105
34106 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34107 PyObject *resultobj;
34108 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34109 wxMenu *arg2 = (wxMenu *) 0 ;
34110 wxString *arg3 = 0 ;
34111 bool result;
34112 bool temp3 = false ;
34113 PyObject * obj0 = 0 ;
34114 PyObject * obj1 = 0 ;
34115 PyObject * obj2 = 0 ;
34116 char *kwnames[] = {
34117 (char *) "self",(char *) "menu",(char *) "title", NULL
34118 };
34119
34120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34122 if (SWIG_arg_fail(1)) SWIG_fail;
34123 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34124 if (SWIG_arg_fail(2)) SWIG_fail;
34125 {
34126 arg3 = wxString_in_helper(obj2);
34127 if (arg3 == NULL) SWIG_fail;
34128 temp3 = true;
34129 }
34130 {
34131 PyThreadState* __tstate = wxPyBeginAllowThreads();
34132 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34133
34134 wxPyEndAllowThreads(__tstate);
34135 if (PyErr_Occurred()) SWIG_fail;
34136 }
34137 {
34138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34139 }
34140 {
34141 if (temp3)
34142 delete arg3;
34143 }
34144 return resultobj;
34145 fail:
34146 {
34147 if (temp3)
34148 delete arg3;
34149 }
34150 return NULL;
34151 }
34152
34153
34154 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34155 PyObject *resultobj;
34156 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34157 size_t arg2 ;
34158 wxMenu *arg3 = (wxMenu *) 0 ;
34159 wxString *arg4 = 0 ;
34160 bool result;
34161 bool temp4 = false ;
34162 PyObject * obj0 = 0 ;
34163 PyObject * obj1 = 0 ;
34164 PyObject * obj2 = 0 ;
34165 PyObject * obj3 = 0 ;
34166 char *kwnames[] = {
34167 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34168 };
34169
34170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34172 if (SWIG_arg_fail(1)) SWIG_fail;
34173 {
34174 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34175 if (SWIG_arg_fail(2)) SWIG_fail;
34176 }
34177 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34178 if (SWIG_arg_fail(3)) SWIG_fail;
34179 {
34180 arg4 = wxString_in_helper(obj3);
34181 if (arg4 == NULL) SWIG_fail;
34182 temp4 = true;
34183 }
34184 {
34185 PyThreadState* __tstate = wxPyBeginAllowThreads();
34186 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34187
34188 wxPyEndAllowThreads(__tstate);
34189 if (PyErr_Occurred()) SWIG_fail;
34190 }
34191 {
34192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34193 }
34194 {
34195 if (temp4)
34196 delete arg4;
34197 }
34198 return resultobj;
34199 fail:
34200 {
34201 if (temp4)
34202 delete arg4;
34203 }
34204 return NULL;
34205 }
34206
34207
34208 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34209 PyObject *resultobj;
34210 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34211 size_t result;
34212 PyObject * obj0 = 0 ;
34213 char *kwnames[] = {
34214 (char *) "self", NULL
34215 };
34216
34217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34219 if (SWIG_arg_fail(1)) SWIG_fail;
34220 {
34221 PyThreadState* __tstate = wxPyBeginAllowThreads();
34222 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34223
34224 wxPyEndAllowThreads(__tstate);
34225 if (PyErr_Occurred()) SWIG_fail;
34226 }
34227 {
34228 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34229 }
34230 return resultobj;
34231 fail:
34232 return NULL;
34233 }
34234
34235
34236 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34237 PyObject *resultobj;
34238 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34239 size_t arg2 ;
34240 wxMenu *result;
34241 PyObject * obj0 = 0 ;
34242 PyObject * obj1 = 0 ;
34243 char *kwnames[] = {
34244 (char *) "self",(char *) "pos", NULL
34245 };
34246
34247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34249 if (SWIG_arg_fail(1)) SWIG_fail;
34250 {
34251 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34252 if (SWIG_arg_fail(2)) SWIG_fail;
34253 }
34254 {
34255 PyThreadState* __tstate = wxPyBeginAllowThreads();
34256 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34257
34258 wxPyEndAllowThreads(__tstate);
34259 if (PyErr_Occurred()) SWIG_fail;
34260 }
34261 {
34262 resultobj = wxPyMake_wxObject(result, 0);
34263 }
34264 return resultobj;
34265 fail:
34266 return NULL;
34267 }
34268
34269
34270 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34271 PyObject *resultobj;
34272 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34273 size_t arg2 ;
34274 wxMenu *arg3 = (wxMenu *) 0 ;
34275 wxString *arg4 = 0 ;
34276 wxMenu *result;
34277 bool temp4 = false ;
34278 PyObject * obj0 = 0 ;
34279 PyObject * obj1 = 0 ;
34280 PyObject * obj2 = 0 ;
34281 PyObject * obj3 = 0 ;
34282 char *kwnames[] = {
34283 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34284 };
34285
34286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34288 if (SWIG_arg_fail(1)) SWIG_fail;
34289 {
34290 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34291 if (SWIG_arg_fail(2)) SWIG_fail;
34292 }
34293 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34294 if (SWIG_arg_fail(3)) SWIG_fail;
34295 {
34296 arg4 = wxString_in_helper(obj3);
34297 if (arg4 == NULL) SWIG_fail;
34298 temp4 = true;
34299 }
34300 {
34301 PyThreadState* __tstate = wxPyBeginAllowThreads();
34302 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34303
34304 wxPyEndAllowThreads(__tstate);
34305 if (PyErr_Occurred()) SWIG_fail;
34306 }
34307 {
34308 resultobj = wxPyMake_wxObject(result, 0);
34309 }
34310 {
34311 if (temp4)
34312 delete arg4;
34313 }
34314 return resultobj;
34315 fail:
34316 {
34317 if (temp4)
34318 delete arg4;
34319 }
34320 return NULL;
34321 }
34322
34323
34324 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34325 PyObject *resultobj;
34326 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34327 size_t arg2 ;
34328 wxMenu *result;
34329 PyObject * obj0 = 0 ;
34330 PyObject * obj1 = 0 ;
34331 char *kwnames[] = {
34332 (char *) "self",(char *) "pos", NULL
34333 };
34334
34335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34337 if (SWIG_arg_fail(1)) SWIG_fail;
34338 {
34339 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34340 if (SWIG_arg_fail(2)) SWIG_fail;
34341 }
34342 {
34343 PyThreadState* __tstate = wxPyBeginAllowThreads();
34344 result = (wxMenu *)(arg1)->Remove(arg2);
34345
34346 wxPyEndAllowThreads(__tstate);
34347 if (PyErr_Occurred()) SWIG_fail;
34348 }
34349 {
34350 resultobj = wxPyMake_wxObject(result, 0);
34351 }
34352 return resultobj;
34353 fail:
34354 return NULL;
34355 }
34356
34357
34358 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34359 PyObject *resultobj;
34360 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34361 size_t arg2 ;
34362 bool arg3 ;
34363 PyObject * obj0 = 0 ;
34364 PyObject * obj1 = 0 ;
34365 PyObject * obj2 = 0 ;
34366 char *kwnames[] = {
34367 (char *) "self",(char *) "pos",(char *) "enable", NULL
34368 };
34369
34370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34372 if (SWIG_arg_fail(1)) SWIG_fail;
34373 {
34374 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34375 if (SWIG_arg_fail(2)) SWIG_fail;
34376 }
34377 {
34378 arg3 = (bool)(SWIG_As_bool(obj2));
34379 if (SWIG_arg_fail(3)) SWIG_fail;
34380 }
34381 {
34382 PyThreadState* __tstate = wxPyBeginAllowThreads();
34383 (arg1)->EnableTop(arg2,arg3);
34384
34385 wxPyEndAllowThreads(__tstate);
34386 if (PyErr_Occurred()) SWIG_fail;
34387 }
34388 Py_INCREF(Py_None); resultobj = Py_None;
34389 return resultobj;
34390 fail:
34391 return NULL;
34392 }
34393
34394
34395 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
34396 PyObject *resultobj;
34397 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34398 size_t arg2 ;
34399 bool result;
34400 PyObject * obj0 = 0 ;
34401 PyObject * obj1 = 0 ;
34402 char *kwnames[] = {
34403 (char *) "self",(char *) "pos", NULL
34404 };
34405
34406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
34407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34408 if (SWIG_arg_fail(1)) SWIG_fail;
34409 {
34410 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34411 if (SWIG_arg_fail(2)) SWIG_fail;
34412 }
34413 {
34414 PyThreadState* __tstate = wxPyBeginAllowThreads();
34415 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
34416
34417 wxPyEndAllowThreads(__tstate);
34418 if (PyErr_Occurred()) SWIG_fail;
34419 }
34420 {
34421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34422 }
34423 return resultobj;
34424 fail:
34425 return NULL;
34426 }
34427
34428
34429 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34430 PyObject *resultobj;
34431 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34432 size_t arg2 ;
34433 wxString *arg3 = 0 ;
34434 bool temp3 = false ;
34435 PyObject * obj0 = 0 ;
34436 PyObject * obj1 = 0 ;
34437 PyObject * obj2 = 0 ;
34438 char *kwnames[] = {
34439 (char *) "self",(char *) "pos",(char *) "label", NULL
34440 };
34441
34442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34444 if (SWIG_arg_fail(1)) SWIG_fail;
34445 {
34446 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34447 if (SWIG_arg_fail(2)) SWIG_fail;
34448 }
34449 {
34450 arg3 = wxString_in_helper(obj2);
34451 if (arg3 == NULL) SWIG_fail;
34452 temp3 = true;
34453 }
34454 {
34455 PyThreadState* __tstate = wxPyBeginAllowThreads();
34456 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
34457
34458 wxPyEndAllowThreads(__tstate);
34459 if (PyErr_Occurred()) SWIG_fail;
34460 }
34461 Py_INCREF(Py_None); resultobj = Py_None;
34462 {
34463 if (temp3)
34464 delete arg3;
34465 }
34466 return resultobj;
34467 fail:
34468 {
34469 if (temp3)
34470 delete arg3;
34471 }
34472 return NULL;
34473 }
34474
34475
34476 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34477 PyObject *resultobj;
34478 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34479 size_t arg2 ;
34480 wxString result;
34481 PyObject * obj0 = 0 ;
34482 PyObject * obj1 = 0 ;
34483 char *kwnames[] = {
34484 (char *) "self",(char *) "pos", NULL
34485 };
34486
34487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
34488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34489 if (SWIG_arg_fail(1)) SWIG_fail;
34490 {
34491 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34492 if (SWIG_arg_fail(2)) SWIG_fail;
34493 }
34494 {
34495 PyThreadState* __tstate = wxPyBeginAllowThreads();
34496 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
34497
34498 wxPyEndAllowThreads(__tstate);
34499 if (PyErr_Occurred()) SWIG_fail;
34500 }
34501 {
34502 #if wxUSE_UNICODE
34503 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34504 #else
34505 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34506 #endif
34507 }
34508 return resultobj;
34509 fail:
34510 return NULL;
34511 }
34512
34513
34514 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34515 PyObject *resultobj;
34516 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34517 wxString *arg2 = 0 ;
34518 wxString *arg3 = 0 ;
34519 int result;
34520 bool temp2 = false ;
34521 bool temp3 = false ;
34522 PyObject * obj0 = 0 ;
34523 PyObject * obj1 = 0 ;
34524 PyObject * obj2 = 0 ;
34525 char *kwnames[] = {
34526 (char *) "self",(char *) "menu",(char *) "item", NULL
34527 };
34528
34529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
34530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34531 if (SWIG_arg_fail(1)) SWIG_fail;
34532 {
34533 arg2 = wxString_in_helper(obj1);
34534 if (arg2 == NULL) SWIG_fail;
34535 temp2 = true;
34536 }
34537 {
34538 arg3 = wxString_in_helper(obj2);
34539 if (arg3 == NULL) SWIG_fail;
34540 temp3 = true;
34541 }
34542 {
34543 PyThreadState* __tstate = wxPyBeginAllowThreads();
34544 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
34545
34546 wxPyEndAllowThreads(__tstate);
34547 if (PyErr_Occurred()) SWIG_fail;
34548 }
34549 {
34550 resultobj = SWIG_From_int((int)(result));
34551 }
34552 {
34553 if (temp2)
34554 delete arg2;
34555 }
34556 {
34557 if (temp3)
34558 delete arg3;
34559 }
34560 return resultobj;
34561 fail:
34562 {
34563 if (temp2)
34564 delete arg2;
34565 }
34566 {
34567 if (temp3)
34568 delete arg3;
34569 }
34570 return NULL;
34571 }
34572
34573
34574 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34575 PyObject *resultobj;
34576 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34577 int arg2 ;
34578 wxMenuItem *result;
34579 PyObject * obj0 = 0 ;
34580 PyObject * obj1 = 0 ;
34581 char *kwnames[] = {
34582 (char *) "self",(char *) "id", NULL
34583 };
34584
34585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34587 if (SWIG_arg_fail(1)) SWIG_fail;
34588 {
34589 arg2 = (int)(SWIG_As_int(obj1));
34590 if (SWIG_arg_fail(2)) SWIG_fail;
34591 }
34592 {
34593 PyThreadState* __tstate = wxPyBeginAllowThreads();
34594 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
34595
34596 wxPyEndAllowThreads(__tstate);
34597 if (PyErr_Occurred()) SWIG_fail;
34598 }
34599 {
34600 resultobj = wxPyMake_wxObject(result, 0);
34601 }
34602 return resultobj;
34603 fail:
34604 return NULL;
34605 }
34606
34607
34608 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34609 PyObject *resultobj;
34610 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34611 wxString *arg2 = 0 ;
34612 int result;
34613 bool temp2 = false ;
34614 PyObject * obj0 = 0 ;
34615 PyObject * obj1 = 0 ;
34616 char *kwnames[] = {
34617 (char *) "self",(char *) "title", NULL
34618 };
34619
34620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
34621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34622 if (SWIG_arg_fail(1)) SWIG_fail;
34623 {
34624 arg2 = wxString_in_helper(obj1);
34625 if (arg2 == NULL) SWIG_fail;
34626 temp2 = true;
34627 }
34628 {
34629 PyThreadState* __tstate = wxPyBeginAllowThreads();
34630 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
34631
34632 wxPyEndAllowThreads(__tstate);
34633 if (PyErr_Occurred()) SWIG_fail;
34634 }
34635 {
34636 resultobj = SWIG_From_int((int)(result));
34637 }
34638 {
34639 if (temp2)
34640 delete arg2;
34641 }
34642 return resultobj;
34643 fail:
34644 {
34645 if (temp2)
34646 delete arg2;
34647 }
34648 return NULL;
34649 }
34650
34651
34652 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34653 PyObject *resultobj;
34654 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34655 int arg2 ;
34656 bool arg3 ;
34657 PyObject * obj0 = 0 ;
34658 PyObject * obj1 = 0 ;
34659 PyObject * obj2 = 0 ;
34660 char *kwnames[] = {
34661 (char *) "self",(char *) "id",(char *) "enable", NULL
34662 };
34663
34664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34666 if (SWIG_arg_fail(1)) SWIG_fail;
34667 {
34668 arg2 = (int)(SWIG_As_int(obj1));
34669 if (SWIG_arg_fail(2)) SWIG_fail;
34670 }
34671 {
34672 arg3 = (bool)(SWIG_As_bool(obj2));
34673 if (SWIG_arg_fail(3)) SWIG_fail;
34674 }
34675 {
34676 PyThreadState* __tstate = wxPyBeginAllowThreads();
34677 (arg1)->Enable(arg2,arg3);
34678
34679 wxPyEndAllowThreads(__tstate);
34680 if (PyErr_Occurred()) SWIG_fail;
34681 }
34682 Py_INCREF(Py_None); resultobj = Py_None;
34683 return resultobj;
34684 fail:
34685 return NULL;
34686 }
34687
34688
34689 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34690 PyObject *resultobj;
34691 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34692 int arg2 ;
34693 bool arg3 ;
34694 PyObject * obj0 = 0 ;
34695 PyObject * obj1 = 0 ;
34696 PyObject * obj2 = 0 ;
34697 char *kwnames[] = {
34698 (char *) "self",(char *) "id",(char *) "check", NULL
34699 };
34700
34701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34703 if (SWIG_arg_fail(1)) SWIG_fail;
34704 {
34705 arg2 = (int)(SWIG_As_int(obj1));
34706 if (SWIG_arg_fail(2)) SWIG_fail;
34707 }
34708 {
34709 arg3 = (bool)(SWIG_As_bool(obj2));
34710 if (SWIG_arg_fail(3)) SWIG_fail;
34711 }
34712 {
34713 PyThreadState* __tstate = wxPyBeginAllowThreads();
34714 (arg1)->Check(arg2,arg3);
34715
34716 wxPyEndAllowThreads(__tstate);
34717 if (PyErr_Occurred()) SWIG_fail;
34718 }
34719 Py_INCREF(Py_None); resultobj = Py_None;
34720 return resultobj;
34721 fail:
34722 return NULL;
34723 }
34724
34725
34726 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34727 PyObject *resultobj;
34728 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34729 int arg2 ;
34730 bool result;
34731 PyObject * obj0 = 0 ;
34732 PyObject * obj1 = 0 ;
34733 char *kwnames[] = {
34734 (char *) "self",(char *) "id", NULL
34735 };
34736
34737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34739 if (SWIG_arg_fail(1)) SWIG_fail;
34740 {
34741 arg2 = (int)(SWIG_As_int(obj1));
34742 if (SWIG_arg_fail(2)) SWIG_fail;
34743 }
34744 {
34745 PyThreadState* __tstate = wxPyBeginAllowThreads();
34746 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
34747
34748 wxPyEndAllowThreads(__tstate);
34749 if (PyErr_Occurred()) SWIG_fail;
34750 }
34751 {
34752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34753 }
34754 return resultobj;
34755 fail:
34756 return NULL;
34757 }
34758
34759
34760 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34761 PyObject *resultobj;
34762 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34763 int arg2 ;
34764 bool result;
34765 PyObject * obj0 = 0 ;
34766 PyObject * obj1 = 0 ;
34767 char *kwnames[] = {
34768 (char *) "self",(char *) "id", NULL
34769 };
34770
34771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34773 if (SWIG_arg_fail(1)) SWIG_fail;
34774 {
34775 arg2 = (int)(SWIG_As_int(obj1));
34776 if (SWIG_arg_fail(2)) SWIG_fail;
34777 }
34778 {
34779 PyThreadState* __tstate = wxPyBeginAllowThreads();
34780 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
34781
34782 wxPyEndAllowThreads(__tstate);
34783 if (PyErr_Occurred()) SWIG_fail;
34784 }
34785 {
34786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34787 }
34788 return resultobj;
34789 fail:
34790 return NULL;
34791 }
34792
34793
34794 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34795 PyObject *resultobj;
34796 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34797 int arg2 ;
34798 wxString *arg3 = 0 ;
34799 bool temp3 = false ;
34800 PyObject * obj0 = 0 ;
34801 PyObject * obj1 = 0 ;
34802 PyObject * obj2 = 0 ;
34803 char *kwnames[] = {
34804 (char *) "self",(char *) "id",(char *) "label", NULL
34805 };
34806
34807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34809 if (SWIG_arg_fail(1)) SWIG_fail;
34810 {
34811 arg2 = (int)(SWIG_As_int(obj1));
34812 if (SWIG_arg_fail(2)) SWIG_fail;
34813 }
34814 {
34815 arg3 = wxString_in_helper(obj2);
34816 if (arg3 == NULL) SWIG_fail;
34817 temp3 = true;
34818 }
34819 {
34820 PyThreadState* __tstate = wxPyBeginAllowThreads();
34821 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34822
34823 wxPyEndAllowThreads(__tstate);
34824 if (PyErr_Occurred()) SWIG_fail;
34825 }
34826 Py_INCREF(Py_None); resultobj = Py_None;
34827 {
34828 if (temp3)
34829 delete arg3;
34830 }
34831 return resultobj;
34832 fail:
34833 {
34834 if (temp3)
34835 delete arg3;
34836 }
34837 return NULL;
34838 }
34839
34840
34841 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34842 PyObject *resultobj;
34843 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34844 int arg2 ;
34845 wxString result;
34846 PyObject * obj0 = 0 ;
34847 PyObject * obj1 = 0 ;
34848 char *kwnames[] = {
34849 (char *) "self",(char *) "id", NULL
34850 };
34851
34852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34854 if (SWIG_arg_fail(1)) SWIG_fail;
34855 {
34856 arg2 = (int)(SWIG_As_int(obj1));
34857 if (SWIG_arg_fail(2)) SWIG_fail;
34858 }
34859 {
34860 PyThreadState* __tstate = wxPyBeginAllowThreads();
34861 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
34862
34863 wxPyEndAllowThreads(__tstate);
34864 if (PyErr_Occurred()) SWIG_fail;
34865 }
34866 {
34867 #if wxUSE_UNICODE
34868 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34869 #else
34870 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34871 #endif
34872 }
34873 return resultobj;
34874 fail:
34875 return NULL;
34876 }
34877
34878
34879 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34880 PyObject *resultobj;
34881 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34882 int arg2 ;
34883 wxString *arg3 = 0 ;
34884 bool temp3 = false ;
34885 PyObject * obj0 = 0 ;
34886 PyObject * obj1 = 0 ;
34887 PyObject * obj2 = 0 ;
34888 char *kwnames[] = {
34889 (char *) "self",(char *) "id",(char *) "helpString", NULL
34890 };
34891
34892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34894 if (SWIG_arg_fail(1)) SWIG_fail;
34895 {
34896 arg2 = (int)(SWIG_As_int(obj1));
34897 if (SWIG_arg_fail(2)) SWIG_fail;
34898 }
34899 {
34900 arg3 = wxString_in_helper(obj2);
34901 if (arg3 == NULL) SWIG_fail;
34902 temp3 = true;
34903 }
34904 {
34905 PyThreadState* __tstate = wxPyBeginAllowThreads();
34906 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34907
34908 wxPyEndAllowThreads(__tstate);
34909 if (PyErr_Occurred()) SWIG_fail;
34910 }
34911 Py_INCREF(Py_None); resultobj = Py_None;
34912 {
34913 if (temp3)
34914 delete arg3;
34915 }
34916 return resultobj;
34917 fail:
34918 {
34919 if (temp3)
34920 delete arg3;
34921 }
34922 return NULL;
34923 }
34924
34925
34926 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34927 PyObject *resultobj;
34928 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34929 int arg2 ;
34930 wxString result;
34931 PyObject * obj0 = 0 ;
34932 PyObject * obj1 = 0 ;
34933 char *kwnames[] = {
34934 (char *) "self",(char *) "id", NULL
34935 };
34936
34937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34939 if (SWIG_arg_fail(1)) SWIG_fail;
34940 {
34941 arg2 = (int)(SWIG_As_int(obj1));
34942 if (SWIG_arg_fail(2)) SWIG_fail;
34943 }
34944 {
34945 PyThreadState* __tstate = wxPyBeginAllowThreads();
34946 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
34947
34948 wxPyEndAllowThreads(__tstate);
34949 if (PyErr_Occurred()) SWIG_fail;
34950 }
34951 {
34952 #if wxUSE_UNICODE
34953 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34954 #else
34955 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34956 #endif
34957 }
34958 return resultobj;
34959 fail:
34960 return NULL;
34961 }
34962
34963
34964 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
34965 PyObject *resultobj;
34966 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34967 wxFrame *result;
34968 PyObject * obj0 = 0 ;
34969 char *kwnames[] = {
34970 (char *) "self", NULL
34971 };
34972
34973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
34974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34975 if (SWIG_arg_fail(1)) SWIG_fail;
34976 {
34977 PyThreadState* __tstate = wxPyBeginAllowThreads();
34978 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
34979
34980 wxPyEndAllowThreads(__tstate);
34981 if (PyErr_Occurred()) SWIG_fail;
34982 }
34983 {
34984 resultobj = wxPyMake_wxObject(result, 0);
34985 }
34986 return resultobj;
34987 fail:
34988 return NULL;
34989 }
34990
34991
34992 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34993 PyObject *resultobj;
34994 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34995 bool result;
34996 PyObject * obj0 = 0 ;
34997 char *kwnames[] = {
34998 (char *) "self", NULL
34999 };
35000
35001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35003 if (SWIG_arg_fail(1)) SWIG_fail;
35004 {
35005 PyThreadState* __tstate = wxPyBeginAllowThreads();
35006 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35007
35008 wxPyEndAllowThreads(__tstate);
35009 if (PyErr_Occurred()) SWIG_fail;
35010 }
35011 {
35012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35013 }
35014 return resultobj;
35015 fail:
35016 return NULL;
35017 }
35018
35019
35020 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35021 PyObject *resultobj;
35022 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35023 wxFrame *arg2 = (wxFrame *) 0 ;
35024 PyObject * obj0 = 0 ;
35025 PyObject * obj1 = 0 ;
35026 char *kwnames[] = {
35027 (char *) "self",(char *) "frame", NULL
35028 };
35029
35030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35032 if (SWIG_arg_fail(1)) SWIG_fail;
35033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35034 if (SWIG_arg_fail(2)) SWIG_fail;
35035 {
35036 PyThreadState* __tstate = wxPyBeginAllowThreads();
35037 (arg1)->Attach(arg2);
35038
35039 wxPyEndAllowThreads(__tstate);
35040 if (PyErr_Occurred()) SWIG_fail;
35041 }
35042 Py_INCREF(Py_None); resultobj = Py_None;
35043 return resultobj;
35044 fail:
35045 return NULL;
35046 }
35047
35048
35049 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35050 PyObject *resultobj;
35051 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35052 PyObject * obj0 = 0 ;
35053 char *kwnames[] = {
35054 (char *) "self", NULL
35055 };
35056
35057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35059 if (SWIG_arg_fail(1)) SWIG_fail;
35060 {
35061 PyThreadState* __tstate = wxPyBeginAllowThreads();
35062 (arg1)->Detach();
35063
35064 wxPyEndAllowThreads(__tstate);
35065 if (PyErr_Occurred()) SWIG_fail;
35066 }
35067 Py_INCREF(Py_None); resultobj = Py_None;
35068 return resultobj;
35069 fail:
35070 return NULL;
35071 }
35072
35073
35074 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35075 PyObject *obj;
35076 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35077 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35078 Py_INCREF(obj);
35079 return Py_BuildValue((char *)"");
35080 }
35081 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35082 PyObject *resultobj;
35083 wxMenu *arg1 = (wxMenu *) NULL ;
35084 int arg2 = (int) wxID_ANY ;
35085 wxString const &arg3_defvalue = wxPyEmptyString ;
35086 wxString *arg3 = (wxString *) &arg3_defvalue ;
35087 wxString const &arg4_defvalue = wxPyEmptyString ;
35088 wxString *arg4 = (wxString *) &arg4_defvalue ;
35089 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35090 wxMenu *arg6 = (wxMenu *) NULL ;
35091 wxMenuItem *result;
35092 bool temp3 = false ;
35093 bool temp4 = false ;
35094 PyObject * obj0 = 0 ;
35095 PyObject * obj1 = 0 ;
35096 PyObject * obj2 = 0 ;
35097 PyObject * obj3 = 0 ;
35098 PyObject * obj4 = 0 ;
35099 PyObject * obj5 = 0 ;
35100 char *kwnames[] = {
35101 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35102 };
35103
35104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35105 if (obj0) {
35106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35107 if (SWIG_arg_fail(1)) SWIG_fail;
35108 }
35109 if (obj1) {
35110 {
35111 arg2 = (int)(SWIG_As_int(obj1));
35112 if (SWIG_arg_fail(2)) SWIG_fail;
35113 }
35114 }
35115 if (obj2) {
35116 {
35117 arg3 = wxString_in_helper(obj2);
35118 if (arg3 == NULL) SWIG_fail;
35119 temp3 = true;
35120 }
35121 }
35122 if (obj3) {
35123 {
35124 arg4 = wxString_in_helper(obj3);
35125 if (arg4 == NULL) SWIG_fail;
35126 temp4 = true;
35127 }
35128 }
35129 if (obj4) {
35130 {
35131 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35132 if (SWIG_arg_fail(5)) SWIG_fail;
35133 }
35134 }
35135 if (obj5) {
35136 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35137 if (SWIG_arg_fail(6)) SWIG_fail;
35138 }
35139 {
35140 PyThreadState* __tstate = wxPyBeginAllowThreads();
35141 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35142
35143 wxPyEndAllowThreads(__tstate);
35144 if (PyErr_Occurred()) SWIG_fail;
35145 }
35146 {
35147 resultobj = wxPyMake_wxObject(result, 1);
35148 }
35149 {
35150 if (temp3)
35151 delete arg3;
35152 }
35153 {
35154 if (temp4)
35155 delete arg4;
35156 }
35157 return resultobj;
35158 fail:
35159 {
35160 if (temp3)
35161 delete arg3;
35162 }
35163 {
35164 if (temp4)
35165 delete arg4;
35166 }
35167 return NULL;
35168 }
35169
35170
35171 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35172 PyObject *resultobj;
35173 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35174 wxMenu *result;
35175 PyObject * obj0 = 0 ;
35176 char *kwnames[] = {
35177 (char *) "self", NULL
35178 };
35179
35180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35182 if (SWIG_arg_fail(1)) SWIG_fail;
35183 {
35184 PyThreadState* __tstate = wxPyBeginAllowThreads();
35185 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35186
35187 wxPyEndAllowThreads(__tstate);
35188 if (PyErr_Occurred()) SWIG_fail;
35189 }
35190 {
35191 resultobj = wxPyMake_wxObject(result, 0);
35192 }
35193 return resultobj;
35194 fail:
35195 return NULL;
35196 }
35197
35198
35199 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35200 PyObject *resultobj;
35201 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35202 wxMenu *arg2 = (wxMenu *) 0 ;
35203 PyObject * obj0 = 0 ;
35204 PyObject * obj1 = 0 ;
35205 char *kwnames[] = {
35206 (char *) "self",(char *) "menu", NULL
35207 };
35208
35209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35211 if (SWIG_arg_fail(1)) SWIG_fail;
35212 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35213 if (SWIG_arg_fail(2)) SWIG_fail;
35214 {
35215 PyThreadState* __tstate = wxPyBeginAllowThreads();
35216 (arg1)->SetMenu(arg2);
35217
35218 wxPyEndAllowThreads(__tstate);
35219 if (PyErr_Occurred()) SWIG_fail;
35220 }
35221 Py_INCREF(Py_None); resultobj = Py_None;
35222 return resultobj;
35223 fail:
35224 return NULL;
35225 }
35226
35227
35228 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35229 PyObject *resultobj;
35230 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35231 int arg2 ;
35232 PyObject * obj0 = 0 ;
35233 PyObject * obj1 = 0 ;
35234 char *kwnames[] = {
35235 (char *) "self",(char *) "id", NULL
35236 };
35237
35238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35240 if (SWIG_arg_fail(1)) SWIG_fail;
35241 {
35242 arg2 = (int)(SWIG_As_int(obj1));
35243 if (SWIG_arg_fail(2)) SWIG_fail;
35244 }
35245 {
35246 PyThreadState* __tstate = wxPyBeginAllowThreads();
35247 (arg1)->SetId(arg2);
35248
35249 wxPyEndAllowThreads(__tstate);
35250 if (PyErr_Occurred()) SWIG_fail;
35251 }
35252 Py_INCREF(Py_None); resultobj = Py_None;
35253 return resultobj;
35254 fail:
35255 return NULL;
35256 }
35257
35258
35259 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35260 PyObject *resultobj;
35261 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35262 int result;
35263 PyObject * obj0 = 0 ;
35264 char *kwnames[] = {
35265 (char *) "self", NULL
35266 };
35267
35268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35270 if (SWIG_arg_fail(1)) SWIG_fail;
35271 {
35272 PyThreadState* __tstate = wxPyBeginAllowThreads();
35273 result = (int)((wxMenuItem const *)arg1)->GetId();
35274
35275 wxPyEndAllowThreads(__tstate);
35276 if (PyErr_Occurred()) SWIG_fail;
35277 }
35278 {
35279 resultobj = SWIG_From_int((int)(result));
35280 }
35281 return resultobj;
35282 fail:
35283 return NULL;
35284 }
35285
35286
35287 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35288 PyObject *resultobj;
35289 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35290 bool result;
35291 PyObject * obj0 = 0 ;
35292 char *kwnames[] = {
35293 (char *) "self", NULL
35294 };
35295
35296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35298 if (SWIG_arg_fail(1)) SWIG_fail;
35299 {
35300 PyThreadState* __tstate = wxPyBeginAllowThreads();
35301 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35302
35303 wxPyEndAllowThreads(__tstate);
35304 if (PyErr_Occurred()) SWIG_fail;
35305 }
35306 {
35307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35308 }
35309 return resultobj;
35310 fail:
35311 return NULL;
35312 }
35313
35314
35315 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35316 PyObject *resultobj;
35317 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35318 wxString *arg2 = 0 ;
35319 bool temp2 = false ;
35320 PyObject * obj0 = 0 ;
35321 PyObject * obj1 = 0 ;
35322 char *kwnames[] = {
35323 (char *) "self",(char *) "str", NULL
35324 };
35325
35326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35328 if (SWIG_arg_fail(1)) SWIG_fail;
35329 {
35330 arg2 = wxString_in_helper(obj1);
35331 if (arg2 == NULL) SWIG_fail;
35332 temp2 = true;
35333 }
35334 {
35335 PyThreadState* __tstate = wxPyBeginAllowThreads();
35336 (arg1)->SetText((wxString const &)*arg2);
35337
35338 wxPyEndAllowThreads(__tstate);
35339 if (PyErr_Occurred()) SWIG_fail;
35340 }
35341 Py_INCREF(Py_None); resultobj = Py_None;
35342 {
35343 if (temp2)
35344 delete arg2;
35345 }
35346 return resultobj;
35347 fail:
35348 {
35349 if (temp2)
35350 delete arg2;
35351 }
35352 return NULL;
35353 }
35354
35355
35356 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35357 PyObject *resultobj;
35358 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35359 wxString result;
35360 PyObject * obj0 = 0 ;
35361 char *kwnames[] = {
35362 (char *) "self", NULL
35363 };
35364
35365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
35366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35367 if (SWIG_arg_fail(1)) SWIG_fail;
35368 {
35369 PyThreadState* __tstate = wxPyBeginAllowThreads();
35370 result = ((wxMenuItem const *)arg1)->GetLabel();
35371
35372 wxPyEndAllowThreads(__tstate);
35373 if (PyErr_Occurred()) SWIG_fail;
35374 }
35375 {
35376 #if wxUSE_UNICODE
35377 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35378 #else
35379 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35380 #endif
35381 }
35382 return resultobj;
35383 fail:
35384 return NULL;
35385 }
35386
35387
35388 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
35389 PyObject *resultobj;
35390 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35391 wxString *result;
35392 PyObject * obj0 = 0 ;
35393 char *kwnames[] = {
35394 (char *) "self", NULL
35395 };
35396
35397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
35398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35399 if (SWIG_arg_fail(1)) SWIG_fail;
35400 {
35401 PyThreadState* __tstate = wxPyBeginAllowThreads();
35402 {
35403 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
35404 result = (wxString *) &_result_ref;
35405 }
35406
35407 wxPyEndAllowThreads(__tstate);
35408 if (PyErr_Occurred()) SWIG_fail;
35409 }
35410 {
35411 #if wxUSE_UNICODE
35412 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35413 #else
35414 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35415 #endif
35416 }
35417 return resultobj;
35418 fail:
35419 return NULL;
35420 }
35421
35422
35423 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
35424 PyObject *resultobj;
35425 wxString *arg1 = 0 ;
35426 wxString result;
35427 bool temp1 = false ;
35428 PyObject * obj0 = 0 ;
35429 char *kwnames[] = {
35430 (char *) "text", NULL
35431 };
35432
35433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
35434 {
35435 arg1 = wxString_in_helper(obj0);
35436 if (arg1 == NULL) SWIG_fail;
35437 temp1 = true;
35438 }
35439 {
35440 PyThreadState* __tstate = wxPyBeginAllowThreads();
35441 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
35442
35443 wxPyEndAllowThreads(__tstate);
35444 if (PyErr_Occurred()) SWIG_fail;
35445 }
35446 {
35447 #if wxUSE_UNICODE
35448 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35449 #else
35450 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35451 #endif
35452 }
35453 {
35454 if (temp1)
35455 delete arg1;
35456 }
35457 return resultobj;
35458 fail:
35459 {
35460 if (temp1)
35461 delete arg1;
35462 }
35463 return NULL;
35464 }
35465
35466
35467 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35468 PyObject *resultobj;
35469 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35470 wxItemKind result;
35471 PyObject * obj0 = 0 ;
35472 char *kwnames[] = {
35473 (char *) "self", NULL
35474 };
35475
35476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
35477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35478 if (SWIG_arg_fail(1)) SWIG_fail;
35479 {
35480 PyThreadState* __tstate = wxPyBeginAllowThreads();
35481 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
35482
35483 wxPyEndAllowThreads(__tstate);
35484 if (PyErr_Occurred()) SWIG_fail;
35485 }
35486 resultobj = SWIG_From_int((result));
35487 return resultobj;
35488 fail:
35489 return NULL;
35490 }
35491
35492
35493 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35494 PyObject *resultobj;
35495 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35496 wxItemKind arg2 ;
35497 PyObject * obj0 = 0 ;
35498 PyObject * obj1 = 0 ;
35499 char *kwnames[] = {
35500 (char *) "self",(char *) "kind", NULL
35501 };
35502
35503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
35504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35505 if (SWIG_arg_fail(1)) SWIG_fail;
35506 {
35507 arg2 = (wxItemKind)(SWIG_As_int(obj1));
35508 if (SWIG_arg_fail(2)) SWIG_fail;
35509 }
35510 {
35511 PyThreadState* __tstate = wxPyBeginAllowThreads();
35512 (arg1)->SetKind((wxItemKind )arg2);
35513
35514 wxPyEndAllowThreads(__tstate);
35515 if (PyErr_Occurred()) SWIG_fail;
35516 }
35517 Py_INCREF(Py_None); resultobj = Py_None;
35518 return resultobj;
35519 fail:
35520 return NULL;
35521 }
35522
35523
35524 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35525 PyObject *resultobj;
35526 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35527 bool arg2 ;
35528 PyObject * obj0 = 0 ;
35529 PyObject * obj1 = 0 ;
35530 char *kwnames[] = {
35531 (char *) "self",(char *) "checkable", NULL
35532 };
35533
35534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
35535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35536 if (SWIG_arg_fail(1)) SWIG_fail;
35537 {
35538 arg2 = (bool)(SWIG_As_bool(obj1));
35539 if (SWIG_arg_fail(2)) SWIG_fail;
35540 }
35541 {
35542 PyThreadState* __tstate = wxPyBeginAllowThreads();
35543 (arg1)->SetCheckable(arg2);
35544
35545 wxPyEndAllowThreads(__tstate);
35546 if (PyErr_Occurred()) SWIG_fail;
35547 }
35548 Py_INCREF(Py_None); resultobj = Py_None;
35549 return resultobj;
35550 fail:
35551 return NULL;
35552 }
35553
35554
35555 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35556 PyObject *resultobj;
35557 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35558 bool result;
35559 PyObject * obj0 = 0 ;
35560 char *kwnames[] = {
35561 (char *) "self", NULL
35562 };
35563
35564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
35565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35566 if (SWIG_arg_fail(1)) SWIG_fail;
35567 {
35568 PyThreadState* __tstate = wxPyBeginAllowThreads();
35569 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
35570
35571 wxPyEndAllowThreads(__tstate);
35572 if (PyErr_Occurred()) SWIG_fail;
35573 }
35574 {
35575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35576 }
35577 return resultobj;
35578 fail:
35579 return NULL;
35580 }
35581
35582
35583 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35584 PyObject *resultobj;
35585 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35586 bool result;
35587 PyObject * obj0 = 0 ;
35588 char *kwnames[] = {
35589 (char *) "self", NULL
35590 };
35591
35592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
35593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35594 if (SWIG_arg_fail(1)) SWIG_fail;
35595 {
35596 PyThreadState* __tstate = wxPyBeginAllowThreads();
35597 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
35598
35599 wxPyEndAllowThreads(__tstate);
35600 if (PyErr_Occurred()) SWIG_fail;
35601 }
35602 {
35603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35604 }
35605 return resultobj;
35606 fail:
35607 return NULL;
35608 }
35609
35610
35611 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35612 PyObject *resultobj;
35613 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35614 wxMenu *arg2 = (wxMenu *) 0 ;
35615 PyObject * obj0 = 0 ;
35616 PyObject * obj1 = 0 ;
35617 char *kwnames[] = {
35618 (char *) "self",(char *) "menu", NULL
35619 };
35620
35621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
35622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35623 if (SWIG_arg_fail(1)) SWIG_fail;
35624 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35625 if (SWIG_arg_fail(2)) SWIG_fail;
35626 {
35627 PyThreadState* __tstate = wxPyBeginAllowThreads();
35628 (arg1)->SetSubMenu(arg2);
35629
35630 wxPyEndAllowThreads(__tstate);
35631 if (PyErr_Occurred()) SWIG_fail;
35632 }
35633 Py_INCREF(Py_None); resultobj = Py_None;
35634 return resultobj;
35635 fail:
35636 return NULL;
35637 }
35638
35639
35640 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35641 PyObject *resultobj;
35642 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35643 wxMenu *result;
35644 PyObject * obj0 = 0 ;
35645 char *kwnames[] = {
35646 (char *) "self", NULL
35647 };
35648
35649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
35650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35651 if (SWIG_arg_fail(1)) SWIG_fail;
35652 {
35653 PyThreadState* __tstate = wxPyBeginAllowThreads();
35654 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
35655
35656 wxPyEndAllowThreads(__tstate);
35657 if (PyErr_Occurred()) SWIG_fail;
35658 }
35659 {
35660 resultobj = wxPyMake_wxObject(result, 0);
35661 }
35662 return resultobj;
35663 fail:
35664 return NULL;
35665 }
35666
35667
35668 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35669 PyObject *resultobj;
35670 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35671 bool arg2 = (bool) true ;
35672 PyObject * obj0 = 0 ;
35673 PyObject * obj1 = 0 ;
35674 char *kwnames[] = {
35675 (char *) "self",(char *) "enable", NULL
35676 };
35677
35678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
35679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35680 if (SWIG_arg_fail(1)) SWIG_fail;
35681 if (obj1) {
35682 {
35683 arg2 = (bool)(SWIG_As_bool(obj1));
35684 if (SWIG_arg_fail(2)) SWIG_fail;
35685 }
35686 }
35687 {
35688 PyThreadState* __tstate = wxPyBeginAllowThreads();
35689 (arg1)->Enable(arg2);
35690
35691 wxPyEndAllowThreads(__tstate);
35692 if (PyErr_Occurred()) SWIG_fail;
35693 }
35694 Py_INCREF(Py_None); resultobj = Py_None;
35695 return resultobj;
35696 fail:
35697 return NULL;
35698 }
35699
35700
35701 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35702 PyObject *resultobj;
35703 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35704 bool result;
35705 PyObject * obj0 = 0 ;
35706 char *kwnames[] = {
35707 (char *) "self", NULL
35708 };
35709
35710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
35711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35712 if (SWIG_arg_fail(1)) SWIG_fail;
35713 {
35714 PyThreadState* __tstate = wxPyBeginAllowThreads();
35715 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
35716
35717 wxPyEndAllowThreads(__tstate);
35718 if (PyErr_Occurred()) SWIG_fail;
35719 }
35720 {
35721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35722 }
35723 return resultobj;
35724 fail:
35725 return NULL;
35726 }
35727
35728
35729 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35730 PyObject *resultobj;
35731 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35732 bool arg2 = (bool) true ;
35733 PyObject * obj0 = 0 ;
35734 PyObject * obj1 = 0 ;
35735 char *kwnames[] = {
35736 (char *) "self",(char *) "check", NULL
35737 };
35738
35739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
35740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35741 if (SWIG_arg_fail(1)) SWIG_fail;
35742 if (obj1) {
35743 {
35744 arg2 = (bool)(SWIG_As_bool(obj1));
35745 if (SWIG_arg_fail(2)) SWIG_fail;
35746 }
35747 }
35748 {
35749 PyThreadState* __tstate = wxPyBeginAllowThreads();
35750 (arg1)->Check(arg2);
35751
35752 wxPyEndAllowThreads(__tstate);
35753 if (PyErr_Occurred()) SWIG_fail;
35754 }
35755 Py_INCREF(Py_None); resultobj = Py_None;
35756 return resultobj;
35757 fail:
35758 return NULL;
35759 }
35760
35761
35762 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35763 PyObject *resultobj;
35764 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35765 bool result;
35766 PyObject * obj0 = 0 ;
35767 char *kwnames[] = {
35768 (char *) "self", NULL
35769 };
35770
35771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
35772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35773 if (SWIG_arg_fail(1)) SWIG_fail;
35774 {
35775 PyThreadState* __tstate = wxPyBeginAllowThreads();
35776 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
35777
35778 wxPyEndAllowThreads(__tstate);
35779 if (PyErr_Occurred()) SWIG_fail;
35780 }
35781 {
35782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35783 }
35784 return resultobj;
35785 fail:
35786 return NULL;
35787 }
35788
35789
35790 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
35791 PyObject *resultobj;
35792 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35793 PyObject * obj0 = 0 ;
35794 char *kwnames[] = {
35795 (char *) "self", NULL
35796 };
35797
35798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
35799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35800 if (SWIG_arg_fail(1)) SWIG_fail;
35801 {
35802 PyThreadState* __tstate = wxPyBeginAllowThreads();
35803 (arg1)->Toggle();
35804
35805 wxPyEndAllowThreads(__tstate);
35806 if (PyErr_Occurred()) SWIG_fail;
35807 }
35808 Py_INCREF(Py_None); resultobj = Py_None;
35809 return resultobj;
35810 fail:
35811 return NULL;
35812 }
35813
35814
35815 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
35816 PyObject *resultobj;
35817 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35818 wxString *arg2 = 0 ;
35819 bool temp2 = false ;
35820 PyObject * obj0 = 0 ;
35821 PyObject * obj1 = 0 ;
35822 char *kwnames[] = {
35823 (char *) "self",(char *) "str", NULL
35824 };
35825
35826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
35827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35828 if (SWIG_arg_fail(1)) SWIG_fail;
35829 {
35830 arg2 = wxString_in_helper(obj1);
35831 if (arg2 == NULL) SWIG_fail;
35832 temp2 = true;
35833 }
35834 {
35835 PyThreadState* __tstate = wxPyBeginAllowThreads();
35836 (arg1)->SetHelp((wxString const &)*arg2);
35837
35838 wxPyEndAllowThreads(__tstate);
35839 if (PyErr_Occurred()) SWIG_fail;
35840 }
35841 Py_INCREF(Py_None); resultobj = Py_None;
35842 {
35843 if (temp2)
35844 delete arg2;
35845 }
35846 return resultobj;
35847 fail:
35848 {
35849 if (temp2)
35850 delete arg2;
35851 }
35852 return NULL;
35853 }
35854
35855
35856 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
35857 PyObject *resultobj;
35858 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35859 wxString *result;
35860 PyObject * obj0 = 0 ;
35861 char *kwnames[] = {
35862 (char *) "self", NULL
35863 };
35864
35865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
35866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35867 if (SWIG_arg_fail(1)) SWIG_fail;
35868 {
35869 PyThreadState* __tstate = wxPyBeginAllowThreads();
35870 {
35871 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
35872 result = (wxString *) &_result_ref;
35873 }
35874
35875 wxPyEndAllowThreads(__tstate);
35876 if (PyErr_Occurred()) SWIG_fail;
35877 }
35878 {
35879 #if wxUSE_UNICODE
35880 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35881 #else
35882 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35883 #endif
35884 }
35885 return resultobj;
35886 fail:
35887 return NULL;
35888 }
35889
35890
35891 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
35892 PyObject *resultobj;
35893 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35894 wxAcceleratorEntry *result;
35895 PyObject * obj0 = 0 ;
35896 char *kwnames[] = {
35897 (char *) "self", NULL
35898 };
35899
35900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
35901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35902 if (SWIG_arg_fail(1)) SWIG_fail;
35903 {
35904 PyThreadState* __tstate = wxPyBeginAllowThreads();
35905 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
35906
35907 wxPyEndAllowThreads(__tstate);
35908 if (PyErr_Occurred()) SWIG_fail;
35909 }
35910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
35911 return resultobj;
35912 fail:
35913 return NULL;
35914 }
35915
35916
35917 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
35918 PyObject *resultobj;
35919 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35920 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
35921 PyObject * obj0 = 0 ;
35922 PyObject * obj1 = 0 ;
35923 char *kwnames[] = {
35924 (char *) "self",(char *) "accel", NULL
35925 };
35926
35927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
35928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35929 if (SWIG_arg_fail(1)) SWIG_fail;
35930 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
35931 if (SWIG_arg_fail(2)) SWIG_fail;
35932 {
35933 PyThreadState* __tstate = wxPyBeginAllowThreads();
35934 (arg1)->SetAccel(arg2);
35935
35936 wxPyEndAllowThreads(__tstate);
35937 if (PyErr_Occurred()) SWIG_fail;
35938 }
35939 Py_INCREF(Py_None); resultobj = Py_None;
35940 return resultobj;
35941 fail:
35942 return NULL;
35943 }
35944
35945
35946 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
35947 PyObject *resultobj;
35948 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35949 wxFont *arg2 = 0 ;
35950 PyObject * obj0 = 0 ;
35951 PyObject * obj1 = 0 ;
35952 char *kwnames[] = {
35953 (char *) "self",(char *) "font", NULL
35954 };
35955
35956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
35957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35958 if (SWIG_arg_fail(1)) SWIG_fail;
35959 {
35960 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
35961 if (SWIG_arg_fail(2)) SWIG_fail;
35962 if (arg2 == NULL) {
35963 SWIG_null_ref("wxFont");
35964 }
35965 if (SWIG_arg_fail(2)) SWIG_fail;
35966 }
35967 {
35968 PyThreadState* __tstate = wxPyBeginAllowThreads();
35969 (arg1)->SetFont((wxFont const &)*arg2);
35970
35971 wxPyEndAllowThreads(__tstate);
35972 if (PyErr_Occurred()) SWIG_fail;
35973 }
35974 Py_INCREF(Py_None); resultobj = Py_None;
35975 return resultobj;
35976 fail:
35977 return NULL;
35978 }
35979
35980
35981 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
35982 PyObject *resultobj;
35983 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35984 wxFont result;
35985 PyObject * obj0 = 0 ;
35986 char *kwnames[] = {
35987 (char *) "self", NULL
35988 };
35989
35990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
35991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35992 if (SWIG_arg_fail(1)) SWIG_fail;
35993 {
35994 PyThreadState* __tstate = wxPyBeginAllowThreads();
35995 result = (arg1)->GetFont();
35996
35997 wxPyEndAllowThreads(__tstate);
35998 if (PyErr_Occurred()) SWIG_fail;
35999 }
36000 {
36001 wxFont * resultptr;
36002 resultptr = new wxFont((wxFont &)(result));
36003 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36004 }
36005 return resultobj;
36006 fail:
36007 return NULL;
36008 }
36009
36010
36011 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36012 PyObject *resultobj;
36013 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36014 wxColour *arg2 = 0 ;
36015 wxColour temp2 ;
36016 PyObject * obj0 = 0 ;
36017 PyObject * obj1 = 0 ;
36018 char *kwnames[] = {
36019 (char *) "self",(char *) "colText", NULL
36020 };
36021
36022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36024 if (SWIG_arg_fail(1)) SWIG_fail;
36025 {
36026 arg2 = &temp2;
36027 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36028 }
36029 {
36030 PyThreadState* __tstate = wxPyBeginAllowThreads();
36031 (arg1)->SetTextColour((wxColour const &)*arg2);
36032
36033 wxPyEndAllowThreads(__tstate);
36034 if (PyErr_Occurred()) SWIG_fail;
36035 }
36036 Py_INCREF(Py_None); resultobj = Py_None;
36037 return resultobj;
36038 fail:
36039 return NULL;
36040 }
36041
36042
36043 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36044 PyObject *resultobj;
36045 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36046 wxColour result;
36047 PyObject * obj0 = 0 ;
36048 char *kwnames[] = {
36049 (char *) "self", NULL
36050 };
36051
36052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36054 if (SWIG_arg_fail(1)) SWIG_fail;
36055 {
36056 PyThreadState* __tstate = wxPyBeginAllowThreads();
36057 result = (arg1)->GetTextColour();
36058
36059 wxPyEndAllowThreads(__tstate);
36060 if (PyErr_Occurred()) SWIG_fail;
36061 }
36062 {
36063 wxColour * resultptr;
36064 resultptr = new wxColour((wxColour &)(result));
36065 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36066 }
36067 return resultobj;
36068 fail:
36069 return NULL;
36070 }
36071
36072
36073 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36074 PyObject *resultobj;
36075 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36076 wxColour *arg2 = 0 ;
36077 wxColour temp2 ;
36078 PyObject * obj0 = 0 ;
36079 PyObject * obj1 = 0 ;
36080 char *kwnames[] = {
36081 (char *) "self",(char *) "colBack", NULL
36082 };
36083
36084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36086 if (SWIG_arg_fail(1)) SWIG_fail;
36087 {
36088 arg2 = &temp2;
36089 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36090 }
36091 {
36092 PyThreadState* __tstate = wxPyBeginAllowThreads();
36093 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
36094
36095 wxPyEndAllowThreads(__tstate);
36096 if (PyErr_Occurred()) SWIG_fail;
36097 }
36098 Py_INCREF(Py_None); resultobj = Py_None;
36099 return resultobj;
36100 fail:
36101 return NULL;
36102 }
36103
36104
36105 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36106 PyObject *resultobj;
36107 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36108 wxColour result;
36109 PyObject * obj0 = 0 ;
36110 char *kwnames[] = {
36111 (char *) "self", NULL
36112 };
36113
36114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36116 if (SWIG_arg_fail(1)) SWIG_fail;
36117 {
36118 PyThreadState* __tstate = wxPyBeginAllowThreads();
36119 result = (arg1)->GetBackgroundColour();
36120
36121 wxPyEndAllowThreads(__tstate);
36122 if (PyErr_Occurred()) SWIG_fail;
36123 }
36124 {
36125 wxColour * resultptr;
36126 resultptr = new wxColour((wxColour &)(result));
36127 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36128 }
36129 return resultobj;
36130 fail:
36131 return NULL;
36132 }
36133
36134
36135 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36136 PyObject *resultobj;
36137 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36138 wxBitmap *arg2 = 0 ;
36139 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36140 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36141 PyObject * obj0 = 0 ;
36142 PyObject * obj1 = 0 ;
36143 PyObject * obj2 = 0 ;
36144 char *kwnames[] = {
36145 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36146 };
36147
36148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36150 if (SWIG_arg_fail(1)) SWIG_fail;
36151 {
36152 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36153 if (SWIG_arg_fail(2)) SWIG_fail;
36154 if (arg2 == NULL) {
36155 SWIG_null_ref("wxBitmap");
36156 }
36157 if (SWIG_arg_fail(2)) SWIG_fail;
36158 }
36159 if (obj2) {
36160 {
36161 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36162 if (SWIG_arg_fail(3)) SWIG_fail;
36163 if (arg3 == NULL) {
36164 SWIG_null_ref("wxBitmap");
36165 }
36166 if (SWIG_arg_fail(3)) SWIG_fail;
36167 }
36168 }
36169 {
36170 PyThreadState* __tstate = wxPyBeginAllowThreads();
36171 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36172
36173 wxPyEndAllowThreads(__tstate);
36174 if (PyErr_Occurred()) SWIG_fail;
36175 }
36176 Py_INCREF(Py_None); resultobj = Py_None;
36177 return resultobj;
36178 fail:
36179 return NULL;
36180 }
36181
36182
36183 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36184 PyObject *resultobj;
36185 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36186 wxBitmap *arg2 = 0 ;
36187 PyObject * obj0 = 0 ;
36188 PyObject * obj1 = 0 ;
36189 char *kwnames[] = {
36190 (char *) "self",(char *) "bmpDisabled", NULL
36191 };
36192
36193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
36194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36195 if (SWIG_arg_fail(1)) SWIG_fail;
36196 {
36197 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36198 if (SWIG_arg_fail(2)) SWIG_fail;
36199 if (arg2 == NULL) {
36200 SWIG_null_ref("wxBitmap");
36201 }
36202 if (SWIG_arg_fail(2)) SWIG_fail;
36203 }
36204 {
36205 PyThreadState* __tstate = wxPyBeginAllowThreads();
36206 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
36207
36208 wxPyEndAllowThreads(__tstate);
36209 if (PyErr_Occurred()) SWIG_fail;
36210 }
36211 Py_INCREF(Py_None); resultobj = Py_None;
36212 return resultobj;
36213 fail:
36214 return NULL;
36215 }
36216
36217
36218 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36219 PyObject *resultobj;
36220 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36221 wxBitmap *result;
36222 PyObject * obj0 = 0 ;
36223 char *kwnames[] = {
36224 (char *) "self", NULL
36225 };
36226
36227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
36228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36229 if (SWIG_arg_fail(1)) SWIG_fail;
36230 {
36231 PyThreadState* __tstate = wxPyBeginAllowThreads();
36232 {
36233 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
36234 result = (wxBitmap *) &_result_ref;
36235 }
36236
36237 wxPyEndAllowThreads(__tstate);
36238 if (PyErr_Occurred()) SWIG_fail;
36239 }
36240 {
36241 wxBitmap* resultptr = new wxBitmap(*result);
36242 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36243 }
36244 return resultobj;
36245 fail:
36246 return NULL;
36247 }
36248
36249
36250 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36251 PyObject *resultobj;
36252 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36253 int arg2 ;
36254 PyObject * obj0 = 0 ;
36255 PyObject * obj1 = 0 ;
36256 char *kwnames[] = {
36257 (char *) "self",(char *) "nWidth", NULL
36258 };
36259
36260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
36261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36262 if (SWIG_arg_fail(1)) SWIG_fail;
36263 {
36264 arg2 = (int)(SWIG_As_int(obj1));
36265 if (SWIG_arg_fail(2)) SWIG_fail;
36266 }
36267 {
36268 PyThreadState* __tstate = wxPyBeginAllowThreads();
36269 (arg1)->SetMarginWidth(arg2);
36270
36271 wxPyEndAllowThreads(__tstate);
36272 if (PyErr_Occurred()) SWIG_fail;
36273 }
36274 Py_INCREF(Py_None); resultobj = Py_None;
36275 return resultobj;
36276 fail:
36277 return NULL;
36278 }
36279
36280
36281 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36282 PyObject *resultobj;
36283 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36284 int result;
36285 PyObject * obj0 = 0 ;
36286 char *kwnames[] = {
36287 (char *) "self", NULL
36288 };
36289
36290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
36291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36292 if (SWIG_arg_fail(1)) SWIG_fail;
36293 {
36294 PyThreadState* __tstate = wxPyBeginAllowThreads();
36295 result = (int)(arg1)->GetMarginWidth();
36296
36297 wxPyEndAllowThreads(__tstate);
36298 if (PyErr_Occurred()) SWIG_fail;
36299 }
36300 {
36301 resultobj = SWIG_From_int((int)(result));
36302 }
36303 return resultobj;
36304 fail:
36305 return NULL;
36306 }
36307
36308
36309 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36310 PyObject *resultobj;
36311 int result;
36312 char *kwnames[] = {
36313 NULL
36314 };
36315
36316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
36317 {
36318 PyThreadState* __tstate = wxPyBeginAllowThreads();
36319 result = (int)wxMenuItem::GetDefaultMarginWidth();
36320
36321 wxPyEndAllowThreads(__tstate);
36322 if (PyErr_Occurred()) SWIG_fail;
36323 }
36324 {
36325 resultobj = SWIG_From_int((int)(result));
36326 }
36327 return resultobj;
36328 fail:
36329 return NULL;
36330 }
36331
36332
36333 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36334 PyObject *resultobj;
36335 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36336 bool result;
36337 PyObject * obj0 = 0 ;
36338 char *kwnames[] = {
36339 (char *) "self", NULL
36340 };
36341
36342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
36343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36344 if (SWIG_arg_fail(1)) SWIG_fail;
36345 {
36346 PyThreadState* __tstate = wxPyBeginAllowThreads();
36347 result = (bool)(arg1)->IsOwnerDrawn();
36348
36349 wxPyEndAllowThreads(__tstate);
36350 if (PyErr_Occurred()) SWIG_fail;
36351 }
36352 {
36353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36354 }
36355 return resultobj;
36356 fail:
36357 return NULL;
36358 }
36359
36360
36361 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36362 PyObject *resultobj;
36363 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36364 bool arg2 = (bool) true ;
36365 PyObject * obj0 = 0 ;
36366 PyObject * obj1 = 0 ;
36367 char *kwnames[] = {
36368 (char *) "self",(char *) "ownerDrawn", NULL
36369 };
36370
36371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
36372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36373 if (SWIG_arg_fail(1)) SWIG_fail;
36374 if (obj1) {
36375 {
36376 arg2 = (bool)(SWIG_As_bool(obj1));
36377 if (SWIG_arg_fail(2)) SWIG_fail;
36378 }
36379 }
36380 {
36381 PyThreadState* __tstate = wxPyBeginAllowThreads();
36382 (arg1)->SetOwnerDrawn(arg2);
36383
36384 wxPyEndAllowThreads(__tstate);
36385 if (PyErr_Occurred()) SWIG_fail;
36386 }
36387 Py_INCREF(Py_None); resultobj = Py_None;
36388 return resultobj;
36389 fail:
36390 return NULL;
36391 }
36392
36393
36394 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36395 PyObject *resultobj;
36396 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36397 PyObject * obj0 = 0 ;
36398 char *kwnames[] = {
36399 (char *) "self", NULL
36400 };
36401
36402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
36403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36404 if (SWIG_arg_fail(1)) SWIG_fail;
36405 {
36406 PyThreadState* __tstate = wxPyBeginAllowThreads();
36407 (arg1)->ResetOwnerDrawn();
36408
36409 wxPyEndAllowThreads(__tstate);
36410 if (PyErr_Occurred()) SWIG_fail;
36411 }
36412 Py_INCREF(Py_None); resultobj = Py_None;
36413 return resultobj;
36414 fail:
36415 return NULL;
36416 }
36417
36418
36419 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36420 PyObject *resultobj;
36421 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36422 wxBitmap *arg2 = 0 ;
36423 PyObject * obj0 = 0 ;
36424 PyObject * obj1 = 0 ;
36425 char *kwnames[] = {
36426 (char *) "self",(char *) "bitmap", NULL
36427 };
36428
36429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
36430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36431 if (SWIG_arg_fail(1)) SWIG_fail;
36432 {
36433 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36434 if (SWIG_arg_fail(2)) SWIG_fail;
36435 if (arg2 == NULL) {
36436 SWIG_null_ref("wxBitmap");
36437 }
36438 if (SWIG_arg_fail(2)) SWIG_fail;
36439 }
36440 {
36441 PyThreadState* __tstate = wxPyBeginAllowThreads();
36442 (arg1)->SetBitmap((wxBitmap const &)*arg2);
36443
36444 wxPyEndAllowThreads(__tstate);
36445 if (PyErr_Occurred()) SWIG_fail;
36446 }
36447 Py_INCREF(Py_None); resultobj = Py_None;
36448 return resultobj;
36449 fail:
36450 return NULL;
36451 }
36452
36453
36454 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36455 PyObject *resultobj;
36456 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36457 wxBitmap *result;
36458 PyObject * obj0 = 0 ;
36459 char *kwnames[] = {
36460 (char *) "self", NULL
36461 };
36462
36463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
36464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36465 if (SWIG_arg_fail(1)) SWIG_fail;
36466 {
36467 PyThreadState* __tstate = wxPyBeginAllowThreads();
36468 {
36469 wxBitmap const &_result_ref = (arg1)->GetBitmap();
36470 result = (wxBitmap *) &_result_ref;
36471 }
36472
36473 wxPyEndAllowThreads(__tstate);
36474 if (PyErr_Occurred()) SWIG_fail;
36475 }
36476 {
36477 wxBitmap* resultptr = new wxBitmap(*result);
36478 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36479 }
36480 return resultobj;
36481 fail:
36482 return NULL;
36483 }
36484
36485
36486 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
36487 PyObject *obj;
36488 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36489 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
36490 Py_INCREF(obj);
36491 return Py_BuildValue((char *)"");
36492 }
36493 static int _wrap_ControlNameStr_set(PyObject *) {
36494 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
36495 return 1;
36496 }
36497
36498
36499 static PyObject *_wrap_ControlNameStr_get(void) {
36500 PyObject *pyobj;
36501
36502 {
36503 #if wxUSE_UNICODE
36504 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36505 #else
36506 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36507 #endif
36508 }
36509 return pyobj;
36510 }
36511
36512
36513 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
36514 PyObject *resultobj;
36515 wxWindow *arg1 = (wxWindow *) 0 ;
36516 int arg2 = (int) -1 ;
36517 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36518 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36519 wxSize const &arg4_defvalue = wxDefaultSize ;
36520 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
36521 long arg5 = (long) 0 ;
36522 wxValidator const &arg6_defvalue = wxDefaultValidator ;
36523 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
36524 wxString const &arg7_defvalue = wxPyControlNameStr ;
36525 wxString *arg7 = (wxString *) &arg7_defvalue ;
36526 wxControl *result;
36527 wxPoint temp3 ;
36528 wxSize temp4 ;
36529 bool temp7 = false ;
36530 PyObject * obj0 = 0 ;
36531 PyObject * obj1 = 0 ;
36532 PyObject * obj2 = 0 ;
36533 PyObject * obj3 = 0 ;
36534 PyObject * obj4 = 0 ;
36535 PyObject * obj5 = 0 ;
36536 PyObject * obj6 = 0 ;
36537 char *kwnames[] = {
36538 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36539 };
36540
36541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
36542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36543 if (SWIG_arg_fail(1)) SWIG_fail;
36544 if (obj1) {
36545 {
36546 arg2 = (int)(SWIG_As_int(obj1));
36547 if (SWIG_arg_fail(2)) SWIG_fail;
36548 }
36549 }
36550 if (obj2) {
36551 {
36552 arg3 = &temp3;
36553 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36554 }
36555 }
36556 if (obj3) {
36557 {
36558 arg4 = &temp4;
36559 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
36560 }
36561 }
36562 if (obj4) {
36563 {
36564 arg5 = (long)(SWIG_As_long(obj4));
36565 if (SWIG_arg_fail(5)) SWIG_fail;
36566 }
36567 }
36568 if (obj5) {
36569 {
36570 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36571 if (SWIG_arg_fail(6)) SWIG_fail;
36572 if (arg6 == NULL) {
36573 SWIG_null_ref("wxValidator");
36574 }
36575 if (SWIG_arg_fail(6)) SWIG_fail;
36576 }
36577 }
36578 if (obj6) {
36579 {
36580 arg7 = wxString_in_helper(obj6);
36581 if (arg7 == NULL) SWIG_fail;
36582 temp7 = true;
36583 }
36584 }
36585 {
36586 if (!wxPyCheckForApp()) SWIG_fail;
36587 PyThreadState* __tstate = wxPyBeginAllowThreads();
36588 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
36589
36590 wxPyEndAllowThreads(__tstate);
36591 if (PyErr_Occurred()) SWIG_fail;
36592 }
36593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36594 {
36595 if (temp7)
36596 delete arg7;
36597 }
36598 return resultobj;
36599 fail:
36600 {
36601 if (temp7)
36602 delete arg7;
36603 }
36604 return NULL;
36605 }
36606
36607
36608 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
36609 PyObject *resultobj;
36610 wxControl *result;
36611 char *kwnames[] = {
36612 NULL
36613 };
36614
36615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
36616 {
36617 if (!wxPyCheckForApp()) SWIG_fail;
36618 PyThreadState* __tstate = wxPyBeginAllowThreads();
36619 result = (wxControl *)new wxControl();
36620
36621 wxPyEndAllowThreads(__tstate);
36622 if (PyErr_Occurred()) SWIG_fail;
36623 }
36624 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36625 return resultobj;
36626 fail:
36627 return NULL;
36628 }
36629
36630
36631 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
36632 PyObject *resultobj;
36633 wxControl *arg1 = (wxControl *) 0 ;
36634 wxWindow *arg2 = (wxWindow *) 0 ;
36635 int arg3 = (int) -1 ;
36636 wxPoint const &arg4_defvalue = wxDefaultPosition ;
36637 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
36638 wxSize const &arg5_defvalue = wxDefaultSize ;
36639 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
36640 long arg6 = (long) 0 ;
36641 wxValidator const &arg7_defvalue = wxDefaultValidator ;
36642 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
36643 wxString const &arg8_defvalue = wxPyControlNameStr ;
36644 wxString *arg8 = (wxString *) &arg8_defvalue ;
36645 bool result;
36646 wxPoint temp4 ;
36647 wxSize temp5 ;
36648 bool temp8 = false ;
36649 PyObject * obj0 = 0 ;
36650 PyObject * obj1 = 0 ;
36651 PyObject * obj2 = 0 ;
36652 PyObject * obj3 = 0 ;
36653 PyObject * obj4 = 0 ;
36654 PyObject * obj5 = 0 ;
36655 PyObject * obj6 = 0 ;
36656 PyObject * obj7 = 0 ;
36657 char *kwnames[] = {
36658 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36659 };
36660
36661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
36662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36663 if (SWIG_arg_fail(1)) SWIG_fail;
36664 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36665 if (SWIG_arg_fail(2)) SWIG_fail;
36666 if (obj2) {
36667 {
36668 arg3 = (int)(SWIG_As_int(obj2));
36669 if (SWIG_arg_fail(3)) SWIG_fail;
36670 }
36671 }
36672 if (obj3) {
36673 {
36674 arg4 = &temp4;
36675 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
36676 }
36677 }
36678 if (obj4) {
36679 {
36680 arg5 = &temp5;
36681 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
36682 }
36683 }
36684 if (obj5) {
36685 {
36686 arg6 = (long)(SWIG_As_long(obj5));
36687 if (SWIG_arg_fail(6)) SWIG_fail;
36688 }
36689 }
36690 if (obj6) {
36691 {
36692 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36693 if (SWIG_arg_fail(7)) SWIG_fail;
36694 if (arg7 == NULL) {
36695 SWIG_null_ref("wxValidator");
36696 }
36697 if (SWIG_arg_fail(7)) SWIG_fail;
36698 }
36699 }
36700 if (obj7) {
36701 {
36702 arg8 = wxString_in_helper(obj7);
36703 if (arg8 == NULL) SWIG_fail;
36704 temp8 = true;
36705 }
36706 }
36707 {
36708 PyThreadState* __tstate = wxPyBeginAllowThreads();
36709 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
36710
36711 wxPyEndAllowThreads(__tstate);
36712 if (PyErr_Occurred()) SWIG_fail;
36713 }
36714 {
36715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36716 }
36717 {
36718 if (temp8)
36719 delete arg8;
36720 }
36721 return resultobj;
36722 fail:
36723 {
36724 if (temp8)
36725 delete arg8;
36726 }
36727 return NULL;
36728 }
36729
36730
36731 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
36732 PyObject *resultobj;
36733 wxControl *arg1 = (wxControl *) 0 ;
36734 wxCommandEvent *arg2 = 0 ;
36735 PyObject * obj0 = 0 ;
36736 PyObject * obj1 = 0 ;
36737 char *kwnames[] = {
36738 (char *) "self",(char *) "event", NULL
36739 };
36740
36741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
36742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36743 if (SWIG_arg_fail(1)) SWIG_fail;
36744 {
36745 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
36746 if (SWIG_arg_fail(2)) SWIG_fail;
36747 if (arg2 == NULL) {
36748 SWIG_null_ref("wxCommandEvent");
36749 }
36750 if (SWIG_arg_fail(2)) SWIG_fail;
36751 }
36752 {
36753 PyThreadState* __tstate = wxPyBeginAllowThreads();
36754 (arg1)->Command(*arg2);
36755
36756 wxPyEndAllowThreads(__tstate);
36757 if (PyErr_Occurred()) SWIG_fail;
36758 }
36759 Py_INCREF(Py_None); resultobj = Py_None;
36760 return resultobj;
36761 fail:
36762 return NULL;
36763 }
36764
36765
36766 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36767 PyObject *resultobj;
36768 wxControl *arg1 = (wxControl *) 0 ;
36769 wxString result;
36770 PyObject * obj0 = 0 ;
36771 char *kwnames[] = {
36772 (char *) "self", NULL
36773 };
36774
36775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
36776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36777 if (SWIG_arg_fail(1)) SWIG_fail;
36778 {
36779 PyThreadState* __tstate = wxPyBeginAllowThreads();
36780 result = (arg1)->GetLabel();
36781
36782 wxPyEndAllowThreads(__tstate);
36783 if (PyErr_Occurred()) SWIG_fail;
36784 }
36785 {
36786 #if wxUSE_UNICODE
36787 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36788 #else
36789 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36790 #endif
36791 }
36792 return resultobj;
36793 fail:
36794 return NULL;
36795 }
36796
36797
36798 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36799 PyObject *resultobj;
36800 wxControl *arg1 = (wxControl *) 0 ;
36801 wxString *arg2 = 0 ;
36802 bool temp2 = false ;
36803 PyObject * obj0 = 0 ;
36804 PyObject * obj1 = 0 ;
36805 char *kwnames[] = {
36806 (char *) "self",(char *) "label", NULL
36807 };
36808
36809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
36810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36811 if (SWIG_arg_fail(1)) SWIG_fail;
36812 {
36813 arg2 = wxString_in_helper(obj1);
36814 if (arg2 == NULL) SWIG_fail;
36815 temp2 = true;
36816 }
36817 {
36818 PyThreadState* __tstate = wxPyBeginAllowThreads();
36819 (arg1)->SetLabel((wxString const &)*arg2);
36820
36821 wxPyEndAllowThreads(__tstate);
36822 if (PyErr_Occurred()) SWIG_fail;
36823 }
36824 Py_INCREF(Py_None); resultobj = Py_None;
36825 {
36826 if (temp2)
36827 delete arg2;
36828 }
36829 return resultobj;
36830 fail:
36831 {
36832 if (temp2)
36833 delete arg2;
36834 }
36835 return NULL;
36836 }
36837
36838
36839 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
36840 PyObject *resultobj;
36841 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
36842 wxVisualAttributes result;
36843 PyObject * obj0 = 0 ;
36844 char *kwnames[] = {
36845 (char *) "variant", NULL
36846 };
36847
36848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
36849 if (obj0) {
36850 {
36851 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
36852 if (SWIG_arg_fail(1)) SWIG_fail;
36853 }
36854 }
36855 {
36856 if (!wxPyCheckForApp()) SWIG_fail;
36857 PyThreadState* __tstate = wxPyBeginAllowThreads();
36858 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
36859
36860 wxPyEndAllowThreads(__tstate);
36861 if (PyErr_Occurred()) SWIG_fail;
36862 }
36863 {
36864 wxVisualAttributes * resultptr;
36865 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
36866 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
36867 }
36868 return resultobj;
36869 fail:
36870 return NULL;
36871 }
36872
36873
36874 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
36875 PyObject *obj;
36876 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36877 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
36878 Py_INCREF(obj);
36879 return Py_BuildValue((char *)"");
36880 }
36881 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
36882 PyObject *resultobj;
36883 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36884 wxString *arg2 = 0 ;
36885 PyObject *arg3 = (PyObject *) NULL ;
36886 int result;
36887 bool temp2 = false ;
36888 PyObject * obj0 = 0 ;
36889 PyObject * obj1 = 0 ;
36890 PyObject * obj2 = 0 ;
36891 char *kwnames[] = {
36892 (char *) "self",(char *) "item",(char *) "clientData", NULL
36893 };
36894
36895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
36896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36897 if (SWIG_arg_fail(1)) SWIG_fail;
36898 {
36899 arg2 = wxString_in_helper(obj1);
36900 if (arg2 == NULL) SWIG_fail;
36901 temp2 = true;
36902 }
36903 if (obj2) {
36904 arg3 = obj2;
36905 }
36906 {
36907 PyThreadState* __tstate = wxPyBeginAllowThreads();
36908 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
36909
36910 wxPyEndAllowThreads(__tstate);
36911 if (PyErr_Occurred()) SWIG_fail;
36912 }
36913 {
36914 resultobj = SWIG_From_int((int)(result));
36915 }
36916 {
36917 if (temp2)
36918 delete arg2;
36919 }
36920 return resultobj;
36921 fail:
36922 {
36923 if (temp2)
36924 delete arg2;
36925 }
36926 return NULL;
36927 }
36928
36929
36930 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
36931 PyObject *resultobj;
36932 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36933 wxArrayString *arg2 = 0 ;
36934 bool temp2 = false ;
36935 PyObject * obj0 = 0 ;
36936 PyObject * obj1 = 0 ;
36937 char *kwnames[] = {
36938 (char *) "self",(char *) "strings", NULL
36939 };
36940
36941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
36942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36943 if (SWIG_arg_fail(1)) SWIG_fail;
36944 {
36945 if (! PySequence_Check(obj1)) {
36946 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
36947 SWIG_fail;
36948 }
36949 arg2 = new wxArrayString;
36950 temp2 = true;
36951 int i, len=PySequence_Length(obj1);
36952 for (i=0; i<len; i++) {
36953 PyObject* item = PySequence_GetItem(obj1, i);
36954 #if wxUSE_UNICODE
36955 PyObject* str = PyObject_Unicode(item);
36956 #else
36957 PyObject* str = PyObject_Str(item);
36958 #endif
36959 if (PyErr_Occurred()) SWIG_fail;
36960 arg2->Add(Py2wxString(str));
36961 Py_DECREF(item);
36962 Py_DECREF(str);
36963 }
36964 }
36965 {
36966 PyThreadState* __tstate = wxPyBeginAllowThreads();
36967 (arg1)->Append((wxArrayString const &)*arg2);
36968
36969 wxPyEndAllowThreads(__tstate);
36970 if (PyErr_Occurred()) SWIG_fail;
36971 }
36972 Py_INCREF(Py_None); resultobj = Py_None;
36973 {
36974 if (temp2) delete arg2;
36975 }
36976 return resultobj;
36977 fail:
36978 {
36979 if (temp2) delete arg2;
36980 }
36981 return NULL;
36982 }
36983
36984
36985 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
36986 PyObject *resultobj;
36987 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36988 wxString *arg2 = 0 ;
36989 int arg3 ;
36990 PyObject *arg4 = (PyObject *) NULL ;
36991 int result;
36992 bool temp2 = false ;
36993 PyObject * obj0 = 0 ;
36994 PyObject * obj1 = 0 ;
36995 PyObject * obj2 = 0 ;
36996 PyObject * obj3 = 0 ;
36997 char *kwnames[] = {
36998 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
36999 };
37000
37001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37003 if (SWIG_arg_fail(1)) SWIG_fail;
37004 {
37005 arg2 = wxString_in_helper(obj1);
37006 if (arg2 == NULL) SWIG_fail;
37007 temp2 = true;
37008 }
37009 {
37010 arg3 = (int)(SWIG_As_int(obj2));
37011 if (SWIG_arg_fail(3)) SWIG_fail;
37012 }
37013 if (obj3) {
37014 arg4 = obj3;
37015 }
37016 {
37017 PyThreadState* __tstate = wxPyBeginAllowThreads();
37018 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37019
37020 wxPyEndAllowThreads(__tstate);
37021 if (PyErr_Occurred()) SWIG_fail;
37022 }
37023 {
37024 resultobj = SWIG_From_int((int)(result));
37025 }
37026 {
37027 if (temp2)
37028 delete arg2;
37029 }
37030 return resultobj;
37031 fail:
37032 {
37033 if (temp2)
37034 delete arg2;
37035 }
37036 return NULL;
37037 }
37038
37039
37040 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37041 PyObject *resultobj;
37042 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37043 PyObject * obj0 = 0 ;
37044 char *kwnames[] = {
37045 (char *) "self", NULL
37046 };
37047
37048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37050 if (SWIG_arg_fail(1)) SWIG_fail;
37051 {
37052 PyThreadState* __tstate = wxPyBeginAllowThreads();
37053 (arg1)->Clear();
37054
37055 wxPyEndAllowThreads(__tstate);
37056 if (PyErr_Occurred()) SWIG_fail;
37057 }
37058 Py_INCREF(Py_None); resultobj = Py_None;
37059 return resultobj;
37060 fail:
37061 return NULL;
37062 }
37063
37064
37065 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37066 PyObject *resultobj;
37067 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37068 int arg2 ;
37069 PyObject * obj0 = 0 ;
37070 PyObject * obj1 = 0 ;
37071 char *kwnames[] = {
37072 (char *) "self",(char *) "n", NULL
37073 };
37074
37075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37077 if (SWIG_arg_fail(1)) SWIG_fail;
37078 {
37079 arg2 = (int)(SWIG_As_int(obj1));
37080 if (SWIG_arg_fail(2)) SWIG_fail;
37081 }
37082 {
37083 PyThreadState* __tstate = wxPyBeginAllowThreads();
37084 (arg1)->Delete(arg2);
37085
37086 wxPyEndAllowThreads(__tstate);
37087 if (PyErr_Occurred()) SWIG_fail;
37088 }
37089 Py_INCREF(Py_None); resultobj = Py_None;
37090 return resultobj;
37091 fail:
37092 return NULL;
37093 }
37094
37095
37096 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37097 PyObject *resultobj;
37098 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37099 int result;
37100 PyObject * obj0 = 0 ;
37101 char *kwnames[] = {
37102 (char *) "self", NULL
37103 };
37104
37105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37107 if (SWIG_arg_fail(1)) SWIG_fail;
37108 {
37109 PyThreadState* __tstate = wxPyBeginAllowThreads();
37110 result = (int)((wxItemContainer const *)arg1)->GetCount();
37111
37112 wxPyEndAllowThreads(__tstate);
37113 if (PyErr_Occurred()) SWIG_fail;
37114 }
37115 {
37116 resultobj = SWIG_From_int((int)(result));
37117 }
37118 return resultobj;
37119 fail:
37120 return NULL;
37121 }
37122
37123
37124 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
37125 PyObject *resultobj;
37126 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37127 bool result;
37128 PyObject * obj0 = 0 ;
37129 char *kwnames[] = {
37130 (char *) "self", NULL
37131 };
37132
37133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
37134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37135 if (SWIG_arg_fail(1)) SWIG_fail;
37136 {
37137 PyThreadState* __tstate = wxPyBeginAllowThreads();
37138 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
37139
37140 wxPyEndAllowThreads(__tstate);
37141 if (PyErr_Occurred()) SWIG_fail;
37142 }
37143 {
37144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37145 }
37146 return resultobj;
37147 fail:
37148 return NULL;
37149 }
37150
37151
37152 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
37153 PyObject *resultobj;
37154 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37155 int arg2 ;
37156 wxString result;
37157 PyObject * obj0 = 0 ;
37158 PyObject * obj1 = 0 ;
37159 char *kwnames[] = {
37160 (char *) "self",(char *) "n", NULL
37161 };
37162
37163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
37164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37165 if (SWIG_arg_fail(1)) SWIG_fail;
37166 {
37167 arg2 = (int)(SWIG_As_int(obj1));
37168 if (SWIG_arg_fail(2)) SWIG_fail;
37169 }
37170 {
37171 PyThreadState* __tstate = wxPyBeginAllowThreads();
37172 result = ((wxItemContainer const *)arg1)->GetString(arg2);
37173
37174 wxPyEndAllowThreads(__tstate);
37175 if (PyErr_Occurred()) SWIG_fail;
37176 }
37177 {
37178 #if wxUSE_UNICODE
37179 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37180 #else
37181 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37182 #endif
37183 }
37184 return resultobj;
37185 fail:
37186 return NULL;
37187 }
37188
37189
37190 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
37191 PyObject *resultobj;
37192 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37193 wxArrayString result;
37194 PyObject * obj0 = 0 ;
37195 char *kwnames[] = {
37196 (char *) "self", NULL
37197 };
37198
37199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
37200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37201 if (SWIG_arg_fail(1)) SWIG_fail;
37202 {
37203 PyThreadState* __tstate = wxPyBeginAllowThreads();
37204 result = ((wxItemContainer const *)arg1)->GetStrings();
37205
37206 wxPyEndAllowThreads(__tstate);
37207 if (PyErr_Occurred()) SWIG_fail;
37208 }
37209 {
37210 resultobj = wxArrayString2PyList_helper(result);
37211 }
37212 return resultobj;
37213 fail:
37214 return NULL;
37215 }
37216
37217
37218 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
37219 PyObject *resultobj;
37220 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37221 int arg2 ;
37222 wxString *arg3 = 0 ;
37223 bool temp3 = false ;
37224 PyObject * obj0 = 0 ;
37225 PyObject * obj1 = 0 ;
37226 PyObject * obj2 = 0 ;
37227 char *kwnames[] = {
37228 (char *) "self",(char *) "n",(char *) "s", NULL
37229 };
37230
37231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
37232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37233 if (SWIG_arg_fail(1)) SWIG_fail;
37234 {
37235 arg2 = (int)(SWIG_As_int(obj1));
37236 if (SWIG_arg_fail(2)) SWIG_fail;
37237 }
37238 {
37239 arg3 = wxString_in_helper(obj2);
37240 if (arg3 == NULL) SWIG_fail;
37241 temp3 = true;
37242 }
37243 {
37244 PyThreadState* __tstate = wxPyBeginAllowThreads();
37245 (arg1)->SetString(arg2,(wxString const &)*arg3);
37246
37247 wxPyEndAllowThreads(__tstate);
37248 if (PyErr_Occurred()) SWIG_fail;
37249 }
37250 Py_INCREF(Py_None); resultobj = Py_None;
37251 {
37252 if (temp3)
37253 delete arg3;
37254 }
37255 return resultobj;
37256 fail:
37257 {
37258 if (temp3)
37259 delete arg3;
37260 }
37261 return NULL;
37262 }
37263
37264
37265 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
37266 PyObject *resultobj;
37267 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37268 wxString *arg2 = 0 ;
37269 int result;
37270 bool temp2 = false ;
37271 PyObject * obj0 = 0 ;
37272 PyObject * obj1 = 0 ;
37273 char *kwnames[] = {
37274 (char *) "self",(char *) "s", NULL
37275 };
37276
37277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
37278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37279 if (SWIG_arg_fail(1)) SWIG_fail;
37280 {
37281 arg2 = wxString_in_helper(obj1);
37282 if (arg2 == NULL) SWIG_fail;
37283 temp2 = true;
37284 }
37285 {
37286 PyThreadState* __tstate = wxPyBeginAllowThreads();
37287 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
37288
37289 wxPyEndAllowThreads(__tstate);
37290 if (PyErr_Occurred()) SWIG_fail;
37291 }
37292 {
37293 resultobj = SWIG_From_int((int)(result));
37294 }
37295 {
37296 if (temp2)
37297 delete arg2;
37298 }
37299 return resultobj;
37300 fail:
37301 {
37302 if (temp2)
37303 delete arg2;
37304 }
37305 return NULL;
37306 }
37307
37308
37309 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
37310 PyObject *resultobj;
37311 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37312 int arg2 ;
37313 PyObject * obj0 = 0 ;
37314 PyObject * obj1 = 0 ;
37315 char *kwnames[] = {
37316 (char *) "self",(char *) "n", NULL
37317 };
37318
37319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
37320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37321 if (SWIG_arg_fail(1)) SWIG_fail;
37322 {
37323 arg2 = (int)(SWIG_As_int(obj1));
37324 if (SWIG_arg_fail(2)) SWIG_fail;
37325 }
37326 {
37327 PyThreadState* __tstate = wxPyBeginAllowThreads();
37328 (arg1)->Select(arg2);
37329
37330 wxPyEndAllowThreads(__tstate);
37331 if (PyErr_Occurred()) SWIG_fail;
37332 }
37333 Py_INCREF(Py_None); resultobj = Py_None;
37334 return resultobj;
37335 fail:
37336 return NULL;
37337 }
37338
37339
37340 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37341 PyObject *resultobj;
37342 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37343 int result;
37344 PyObject * obj0 = 0 ;
37345 char *kwnames[] = {
37346 (char *) "self", NULL
37347 };
37348
37349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
37350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37351 if (SWIG_arg_fail(1)) SWIG_fail;
37352 {
37353 PyThreadState* __tstate = wxPyBeginAllowThreads();
37354 result = (int)((wxItemContainer const *)arg1)->GetSelection();
37355
37356 wxPyEndAllowThreads(__tstate);
37357 if (PyErr_Occurred()) SWIG_fail;
37358 }
37359 {
37360 resultobj = SWIG_From_int((int)(result));
37361 }
37362 return resultobj;
37363 fail:
37364 return NULL;
37365 }
37366
37367
37368 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37369 PyObject *resultobj;
37370 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37371 wxString result;
37372 PyObject * obj0 = 0 ;
37373 char *kwnames[] = {
37374 (char *) "self", NULL
37375 };
37376
37377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
37378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37379 if (SWIG_arg_fail(1)) SWIG_fail;
37380 {
37381 PyThreadState* __tstate = wxPyBeginAllowThreads();
37382 result = ((wxItemContainer const *)arg1)->GetStringSelection();
37383
37384 wxPyEndAllowThreads(__tstate);
37385 if (PyErr_Occurred()) SWIG_fail;
37386 }
37387 {
37388 #if wxUSE_UNICODE
37389 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37390 #else
37391 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37392 #endif
37393 }
37394 return resultobj;
37395 fail:
37396 return NULL;
37397 }
37398
37399
37400 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37401 PyObject *resultobj;
37402 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37403 int arg2 ;
37404 PyObject *result;
37405 PyObject * obj0 = 0 ;
37406 PyObject * obj1 = 0 ;
37407 char *kwnames[] = {
37408 (char *) "self",(char *) "n", NULL
37409 };
37410
37411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37413 if (SWIG_arg_fail(1)) SWIG_fail;
37414 {
37415 arg2 = (int)(SWIG_As_int(obj1));
37416 if (SWIG_arg_fail(2)) SWIG_fail;
37417 }
37418 {
37419 PyThreadState* __tstate = wxPyBeginAllowThreads();
37420 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37421
37422 wxPyEndAllowThreads(__tstate);
37423 if (PyErr_Occurred()) SWIG_fail;
37424 }
37425 resultobj = result;
37426 return resultobj;
37427 fail:
37428 return NULL;
37429 }
37430
37431
37432 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37433 PyObject *resultobj;
37434 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37435 int arg2 ;
37436 PyObject *arg3 = (PyObject *) 0 ;
37437 PyObject * obj0 = 0 ;
37438 PyObject * obj1 = 0 ;
37439 PyObject * obj2 = 0 ;
37440 char *kwnames[] = {
37441 (char *) "self",(char *) "n",(char *) "clientData", NULL
37442 };
37443
37444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37446 if (SWIG_arg_fail(1)) SWIG_fail;
37447 {
37448 arg2 = (int)(SWIG_As_int(obj1));
37449 if (SWIG_arg_fail(2)) SWIG_fail;
37450 }
37451 arg3 = obj2;
37452 {
37453 PyThreadState* __tstate = wxPyBeginAllowThreads();
37454 wxItemContainer_SetClientData(arg1,arg2,arg3);
37455
37456 wxPyEndAllowThreads(__tstate);
37457 if (PyErr_Occurred()) SWIG_fail;
37458 }
37459 Py_INCREF(Py_None); resultobj = Py_None;
37460 return resultobj;
37461 fail:
37462 return NULL;
37463 }
37464
37465
37466 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
37467 PyObject *obj;
37468 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37469 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
37470 Py_INCREF(obj);
37471 return Py_BuildValue((char *)"");
37472 }
37473 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
37474 PyObject *obj;
37475 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37476 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
37477 Py_INCREF(obj);
37478 return Py_BuildValue((char *)"");
37479 }
37480 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
37481 PyObject *resultobj;
37482 wxSizerItem *result;
37483 char *kwnames[] = {
37484 NULL
37485 };
37486
37487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
37488 {
37489 PyThreadState* __tstate = wxPyBeginAllowThreads();
37490 result = (wxSizerItem *)new wxSizerItem();
37491
37492 wxPyEndAllowThreads(__tstate);
37493 if (PyErr_Occurred()) SWIG_fail;
37494 }
37495 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37496 return resultobj;
37497 fail:
37498 return NULL;
37499 }
37500
37501
37502 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37503 PyObject *resultobj;
37504 wxWindow *arg1 = (wxWindow *) 0 ;
37505 int arg2 ;
37506 int arg3 ;
37507 int arg4 ;
37508 PyObject *arg5 = (PyObject *) NULL ;
37509 wxSizerItem *result;
37510 PyObject * obj0 = 0 ;
37511 PyObject * obj1 = 0 ;
37512 PyObject * obj2 = 0 ;
37513 PyObject * obj3 = 0 ;
37514 PyObject * obj4 = 0 ;
37515 char *kwnames[] = {
37516 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37517 };
37518
37519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37521 if (SWIG_arg_fail(1)) SWIG_fail;
37522 {
37523 arg2 = (int)(SWIG_As_int(obj1));
37524 if (SWIG_arg_fail(2)) SWIG_fail;
37525 }
37526 {
37527 arg3 = (int)(SWIG_As_int(obj2));
37528 if (SWIG_arg_fail(3)) SWIG_fail;
37529 }
37530 {
37531 arg4 = (int)(SWIG_As_int(obj3));
37532 if (SWIG_arg_fail(4)) SWIG_fail;
37533 }
37534 if (obj4) {
37535 arg5 = obj4;
37536 }
37537 {
37538 PyThreadState* __tstate = wxPyBeginAllowThreads();
37539 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37540
37541 wxPyEndAllowThreads(__tstate);
37542 if (PyErr_Occurred()) SWIG_fail;
37543 }
37544 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37545 return resultobj;
37546 fail:
37547 return NULL;
37548 }
37549
37550
37551 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37552 PyObject *resultobj;
37553 int arg1 ;
37554 int arg2 ;
37555 int arg3 ;
37556 int arg4 ;
37557 int arg5 ;
37558 PyObject *arg6 = (PyObject *) NULL ;
37559 wxSizerItem *result;
37560 PyObject * obj0 = 0 ;
37561 PyObject * obj1 = 0 ;
37562 PyObject * obj2 = 0 ;
37563 PyObject * obj3 = 0 ;
37564 PyObject * obj4 = 0 ;
37565 PyObject * obj5 = 0 ;
37566 char *kwnames[] = {
37567 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37568 };
37569
37570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
37571 {
37572 arg1 = (int)(SWIG_As_int(obj0));
37573 if (SWIG_arg_fail(1)) SWIG_fail;
37574 }
37575 {
37576 arg2 = (int)(SWIG_As_int(obj1));
37577 if (SWIG_arg_fail(2)) SWIG_fail;
37578 }
37579 {
37580 arg3 = (int)(SWIG_As_int(obj2));
37581 if (SWIG_arg_fail(3)) SWIG_fail;
37582 }
37583 {
37584 arg4 = (int)(SWIG_As_int(obj3));
37585 if (SWIG_arg_fail(4)) SWIG_fail;
37586 }
37587 {
37588 arg5 = (int)(SWIG_As_int(obj4));
37589 if (SWIG_arg_fail(5)) SWIG_fail;
37590 }
37591 if (obj5) {
37592 arg6 = obj5;
37593 }
37594 {
37595 PyThreadState* __tstate = wxPyBeginAllowThreads();
37596 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
37597
37598 wxPyEndAllowThreads(__tstate);
37599 if (PyErr_Occurred()) SWIG_fail;
37600 }
37601 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37602 return resultobj;
37603 fail:
37604 return NULL;
37605 }
37606
37607
37608 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37609 PyObject *resultobj;
37610 wxSizer *arg1 = (wxSizer *) 0 ;
37611 int arg2 ;
37612 int arg3 ;
37613 int arg4 ;
37614 PyObject *arg5 = (PyObject *) NULL ;
37615 wxSizerItem *result;
37616 PyObject * obj0 = 0 ;
37617 PyObject * obj1 = 0 ;
37618 PyObject * obj2 = 0 ;
37619 PyObject * obj3 = 0 ;
37620 PyObject * obj4 = 0 ;
37621 char *kwnames[] = {
37622 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37623 };
37624
37625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
37627 if (SWIG_arg_fail(1)) SWIG_fail;
37628 {
37629 arg2 = (int)(SWIG_As_int(obj1));
37630 if (SWIG_arg_fail(2)) SWIG_fail;
37631 }
37632 {
37633 arg3 = (int)(SWIG_As_int(obj2));
37634 if (SWIG_arg_fail(3)) SWIG_fail;
37635 }
37636 {
37637 arg4 = (int)(SWIG_As_int(obj3));
37638 if (SWIG_arg_fail(4)) SWIG_fail;
37639 }
37640 if (obj4) {
37641 arg5 = obj4;
37642 }
37643 {
37644 PyThreadState* __tstate = wxPyBeginAllowThreads();
37645 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37646
37647 wxPyEndAllowThreads(__tstate);
37648 if (PyErr_Occurred()) SWIG_fail;
37649 }
37650 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37651 return resultobj;
37652 fail:
37653 return NULL;
37654 }
37655
37656
37657 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
37658 PyObject *resultobj;
37659 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37660 PyObject * obj0 = 0 ;
37661 char *kwnames[] = {
37662 (char *) "self", NULL
37663 };
37664
37665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
37666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37667 if (SWIG_arg_fail(1)) SWIG_fail;
37668 {
37669 PyThreadState* __tstate = wxPyBeginAllowThreads();
37670 (arg1)->DeleteWindows();
37671
37672 wxPyEndAllowThreads(__tstate);
37673 if (PyErr_Occurred()) SWIG_fail;
37674 }
37675 Py_INCREF(Py_None); resultobj = Py_None;
37676 return resultobj;
37677 fail:
37678 return NULL;
37679 }
37680
37681
37682 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37683 PyObject *resultobj;
37684 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37685 PyObject * obj0 = 0 ;
37686 char *kwnames[] = {
37687 (char *) "self", NULL
37688 };
37689
37690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
37691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37692 if (SWIG_arg_fail(1)) SWIG_fail;
37693 {
37694 PyThreadState* __tstate = wxPyBeginAllowThreads();
37695 (arg1)->DetachSizer();
37696
37697 wxPyEndAllowThreads(__tstate);
37698 if (PyErr_Occurred()) SWIG_fail;
37699 }
37700 Py_INCREF(Py_None); resultobj = Py_None;
37701 return resultobj;
37702 fail:
37703 return NULL;
37704 }
37705
37706
37707 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
37708 PyObject *resultobj;
37709 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37710 wxSize result;
37711 PyObject * obj0 = 0 ;
37712 char *kwnames[] = {
37713 (char *) "self", NULL
37714 };
37715
37716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
37717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37718 if (SWIG_arg_fail(1)) SWIG_fail;
37719 {
37720 PyThreadState* __tstate = wxPyBeginAllowThreads();
37721 result = (arg1)->GetSize();
37722
37723 wxPyEndAllowThreads(__tstate);
37724 if (PyErr_Occurred()) SWIG_fail;
37725 }
37726 {
37727 wxSize * resultptr;
37728 resultptr = new wxSize((wxSize &)(result));
37729 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37730 }
37731 return resultobj;
37732 fail:
37733 return NULL;
37734 }
37735
37736
37737 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
37738 PyObject *resultobj;
37739 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37740 wxSize result;
37741 PyObject * obj0 = 0 ;
37742 char *kwnames[] = {
37743 (char *) "self", NULL
37744 };
37745
37746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
37747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37748 if (SWIG_arg_fail(1)) SWIG_fail;
37749 {
37750 PyThreadState* __tstate = wxPyBeginAllowThreads();
37751 result = (arg1)->CalcMin();
37752
37753 wxPyEndAllowThreads(__tstate);
37754 if (PyErr_Occurred()) SWIG_fail;
37755 }
37756 {
37757 wxSize * resultptr;
37758 resultptr = new wxSize((wxSize &)(result));
37759 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37760 }
37761 return resultobj;
37762 fail:
37763 return NULL;
37764 }
37765
37766
37767 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
37768 PyObject *resultobj;
37769 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37770 wxPoint arg2 ;
37771 wxSize arg3 ;
37772 PyObject * obj0 = 0 ;
37773 PyObject * obj1 = 0 ;
37774 PyObject * obj2 = 0 ;
37775 char *kwnames[] = {
37776 (char *) "self",(char *) "pos",(char *) "size", NULL
37777 };
37778
37779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
37780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37781 if (SWIG_arg_fail(1)) SWIG_fail;
37782 {
37783 wxPoint * argp;
37784 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
37785 if (SWIG_arg_fail(2)) SWIG_fail;
37786 if (argp == NULL) {
37787 SWIG_null_ref("wxPoint");
37788 }
37789 if (SWIG_arg_fail(2)) SWIG_fail;
37790 arg2 = *argp;
37791 }
37792 {
37793 wxSize * argp;
37794 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
37795 if (SWIG_arg_fail(3)) SWIG_fail;
37796 if (argp == NULL) {
37797 SWIG_null_ref("wxSize");
37798 }
37799 if (SWIG_arg_fail(3)) SWIG_fail;
37800 arg3 = *argp;
37801 }
37802 {
37803 PyThreadState* __tstate = wxPyBeginAllowThreads();
37804 (arg1)->SetDimension(arg2,arg3);
37805
37806 wxPyEndAllowThreads(__tstate);
37807 if (PyErr_Occurred()) SWIG_fail;
37808 }
37809 Py_INCREF(Py_None); resultobj = Py_None;
37810 return resultobj;
37811 fail:
37812 return NULL;
37813 }
37814
37815
37816 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
37817 PyObject *resultobj;
37818 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37819 wxSize result;
37820 PyObject * obj0 = 0 ;
37821 char *kwnames[] = {
37822 (char *) "self", NULL
37823 };
37824
37825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
37826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37827 if (SWIG_arg_fail(1)) SWIG_fail;
37828 {
37829 PyThreadState* __tstate = wxPyBeginAllowThreads();
37830 result = (arg1)->GetMinSize();
37831
37832 wxPyEndAllowThreads(__tstate);
37833 if (PyErr_Occurred()) SWIG_fail;
37834 }
37835 {
37836 wxSize * resultptr;
37837 resultptr = new wxSize((wxSize &)(result));
37838 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37839 }
37840 return resultobj;
37841 fail:
37842 return NULL;
37843 }
37844
37845
37846 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37847 PyObject *resultobj;
37848 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37849 wxSize result;
37850 PyObject * obj0 = 0 ;
37851 char *kwnames[] = {
37852 (char *) "self", NULL
37853 };
37854
37855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
37856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37857 if (SWIG_arg_fail(1)) SWIG_fail;
37858 {
37859 PyThreadState* __tstate = wxPyBeginAllowThreads();
37860 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
37861
37862 wxPyEndAllowThreads(__tstate);
37863 if (PyErr_Occurred()) SWIG_fail;
37864 }
37865 {
37866 wxSize * resultptr;
37867 resultptr = new wxSize((wxSize &)(result));
37868 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37869 }
37870 return resultobj;
37871 fail:
37872 return NULL;
37873 }
37874
37875
37876 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
37877 PyObject *resultobj;
37878 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37879 int arg2 ;
37880 int arg3 ;
37881 PyObject * obj0 = 0 ;
37882 PyObject * obj1 = 0 ;
37883 PyObject * obj2 = 0 ;
37884 char *kwnames[] = {
37885 (char *) "self",(char *) "x",(char *) "y", NULL
37886 };
37887
37888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
37889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37890 if (SWIG_arg_fail(1)) SWIG_fail;
37891 {
37892 arg2 = (int)(SWIG_As_int(obj1));
37893 if (SWIG_arg_fail(2)) SWIG_fail;
37894 }
37895 {
37896 arg3 = (int)(SWIG_As_int(obj2));
37897 if (SWIG_arg_fail(3)) SWIG_fail;
37898 }
37899 {
37900 PyThreadState* __tstate = wxPyBeginAllowThreads();
37901 (arg1)->SetInitSize(arg2,arg3);
37902
37903 wxPyEndAllowThreads(__tstate);
37904 if (PyErr_Occurred()) SWIG_fail;
37905 }
37906 Py_INCREF(Py_None); resultobj = Py_None;
37907 return resultobj;
37908 fail:
37909 return NULL;
37910 }
37911
37912
37913 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
37914 PyObject *resultobj;
37915 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37916 int arg2 ;
37917 int arg3 ;
37918 PyObject * obj0 = 0 ;
37919 PyObject * obj1 = 0 ;
37920 PyObject * obj2 = 0 ;
37921 char *kwnames[] = {
37922 (char *) "self",(char *) "width",(char *) "height", NULL
37923 };
37924
37925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
37926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37927 if (SWIG_arg_fail(1)) SWIG_fail;
37928 {
37929 arg2 = (int)(SWIG_As_int(obj1));
37930 if (SWIG_arg_fail(2)) SWIG_fail;
37931 }
37932 {
37933 arg3 = (int)(SWIG_As_int(obj2));
37934 if (SWIG_arg_fail(3)) SWIG_fail;
37935 }
37936 {
37937 PyThreadState* __tstate = wxPyBeginAllowThreads();
37938 (arg1)->SetRatio(arg2,arg3);
37939
37940 wxPyEndAllowThreads(__tstate);
37941 if (PyErr_Occurred()) SWIG_fail;
37942 }
37943 Py_INCREF(Py_None); resultobj = Py_None;
37944 return resultobj;
37945 fail:
37946 return NULL;
37947 }
37948
37949
37950 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
37951 PyObject *resultobj;
37952 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37953 wxSize arg2 ;
37954 PyObject * obj0 = 0 ;
37955 PyObject * obj1 = 0 ;
37956 char *kwnames[] = {
37957 (char *) "self",(char *) "size", NULL
37958 };
37959
37960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
37961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37962 if (SWIG_arg_fail(1)) SWIG_fail;
37963 {
37964 wxSize * argp;
37965 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
37966 if (SWIG_arg_fail(2)) SWIG_fail;
37967 if (argp == NULL) {
37968 SWIG_null_ref("wxSize");
37969 }
37970 if (SWIG_arg_fail(2)) SWIG_fail;
37971 arg2 = *argp;
37972 }
37973 {
37974 PyThreadState* __tstate = wxPyBeginAllowThreads();
37975 (arg1)->SetRatio(arg2);
37976
37977 wxPyEndAllowThreads(__tstate);
37978 if (PyErr_Occurred()) SWIG_fail;
37979 }
37980 Py_INCREF(Py_None); resultobj = Py_None;
37981 return resultobj;
37982 fail:
37983 return NULL;
37984 }
37985
37986
37987 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
37988 PyObject *resultobj;
37989 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37990 float arg2 ;
37991 PyObject * obj0 = 0 ;
37992 PyObject * obj1 = 0 ;
37993 char *kwnames[] = {
37994 (char *) "self",(char *) "ratio", NULL
37995 };
37996
37997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
37998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37999 if (SWIG_arg_fail(1)) SWIG_fail;
38000 {
38001 arg2 = (float)(SWIG_As_float(obj1));
38002 if (SWIG_arg_fail(2)) SWIG_fail;
38003 }
38004 {
38005 PyThreadState* __tstate = wxPyBeginAllowThreads();
38006 (arg1)->SetRatio(arg2);
38007
38008 wxPyEndAllowThreads(__tstate);
38009 if (PyErr_Occurred()) SWIG_fail;
38010 }
38011 Py_INCREF(Py_None); resultobj = Py_None;
38012 return resultobj;
38013 fail:
38014 return NULL;
38015 }
38016
38017
38018 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38019 PyObject *resultobj;
38020 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38021 float result;
38022 PyObject * obj0 = 0 ;
38023 char *kwnames[] = {
38024 (char *) "self", NULL
38025 };
38026
38027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38029 if (SWIG_arg_fail(1)) SWIG_fail;
38030 {
38031 PyThreadState* __tstate = wxPyBeginAllowThreads();
38032 result = (float)(arg1)->GetRatio();
38033
38034 wxPyEndAllowThreads(__tstate);
38035 if (PyErr_Occurred()) SWIG_fail;
38036 }
38037 {
38038 resultobj = SWIG_From_float((float)(result));
38039 }
38040 return resultobj;
38041 fail:
38042 return NULL;
38043 }
38044
38045
38046 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38047 PyObject *resultobj;
38048 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38049 wxRect result;
38050 PyObject * obj0 = 0 ;
38051 char *kwnames[] = {
38052 (char *) "self", NULL
38053 };
38054
38055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38057 if (SWIG_arg_fail(1)) SWIG_fail;
38058 {
38059 PyThreadState* __tstate = wxPyBeginAllowThreads();
38060 result = (arg1)->GetRect();
38061
38062 wxPyEndAllowThreads(__tstate);
38063 if (PyErr_Occurred()) SWIG_fail;
38064 }
38065 {
38066 wxRect * resultptr;
38067 resultptr = new wxRect((wxRect &)(result));
38068 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38069 }
38070 return resultobj;
38071 fail:
38072 return NULL;
38073 }
38074
38075
38076 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38077 PyObject *resultobj;
38078 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38079 bool result;
38080 PyObject * obj0 = 0 ;
38081 char *kwnames[] = {
38082 (char *) "self", NULL
38083 };
38084
38085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38087 if (SWIG_arg_fail(1)) SWIG_fail;
38088 {
38089 PyThreadState* __tstate = wxPyBeginAllowThreads();
38090 result = (bool)(arg1)->IsWindow();
38091
38092 wxPyEndAllowThreads(__tstate);
38093 if (PyErr_Occurred()) SWIG_fail;
38094 }
38095 {
38096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38097 }
38098 return resultobj;
38099 fail:
38100 return NULL;
38101 }
38102
38103
38104 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38105 PyObject *resultobj;
38106 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38107 bool result;
38108 PyObject * obj0 = 0 ;
38109 char *kwnames[] = {
38110 (char *) "self", NULL
38111 };
38112
38113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
38114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38115 if (SWIG_arg_fail(1)) SWIG_fail;
38116 {
38117 PyThreadState* __tstate = wxPyBeginAllowThreads();
38118 result = (bool)(arg1)->IsSizer();
38119
38120 wxPyEndAllowThreads(__tstate);
38121 if (PyErr_Occurred()) SWIG_fail;
38122 }
38123 {
38124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38125 }
38126 return resultobj;
38127 fail:
38128 return NULL;
38129 }
38130
38131
38132 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38133 PyObject *resultobj;
38134 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38135 bool result;
38136 PyObject * obj0 = 0 ;
38137 char *kwnames[] = {
38138 (char *) "self", NULL
38139 };
38140
38141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
38142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38143 if (SWIG_arg_fail(1)) SWIG_fail;
38144 {
38145 PyThreadState* __tstate = wxPyBeginAllowThreads();
38146 result = (bool)(arg1)->IsSpacer();
38147
38148 wxPyEndAllowThreads(__tstate);
38149 if (PyErr_Occurred()) SWIG_fail;
38150 }
38151 {
38152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38153 }
38154 return resultobj;
38155 fail:
38156 return NULL;
38157 }
38158
38159
38160 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38161 PyObject *resultobj;
38162 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38163 int arg2 ;
38164 PyObject * obj0 = 0 ;
38165 PyObject * obj1 = 0 ;
38166 char *kwnames[] = {
38167 (char *) "self",(char *) "proportion", NULL
38168 };
38169
38170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
38171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38172 if (SWIG_arg_fail(1)) SWIG_fail;
38173 {
38174 arg2 = (int)(SWIG_As_int(obj1));
38175 if (SWIG_arg_fail(2)) SWIG_fail;
38176 }
38177 {
38178 PyThreadState* __tstate = wxPyBeginAllowThreads();
38179 (arg1)->SetProportion(arg2);
38180
38181 wxPyEndAllowThreads(__tstate);
38182 if (PyErr_Occurred()) SWIG_fail;
38183 }
38184 Py_INCREF(Py_None); resultobj = Py_None;
38185 return resultobj;
38186 fail:
38187 return NULL;
38188 }
38189
38190
38191 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38192 PyObject *resultobj;
38193 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38194 int result;
38195 PyObject * obj0 = 0 ;
38196 char *kwnames[] = {
38197 (char *) "self", NULL
38198 };
38199
38200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
38201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38202 if (SWIG_arg_fail(1)) SWIG_fail;
38203 {
38204 PyThreadState* __tstate = wxPyBeginAllowThreads();
38205 result = (int)(arg1)->GetProportion();
38206
38207 wxPyEndAllowThreads(__tstate);
38208 if (PyErr_Occurred()) SWIG_fail;
38209 }
38210 {
38211 resultobj = SWIG_From_int((int)(result));
38212 }
38213 return resultobj;
38214 fail:
38215 return NULL;
38216 }
38217
38218
38219 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38220 PyObject *resultobj;
38221 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38222 int arg2 ;
38223 PyObject * obj0 = 0 ;
38224 PyObject * obj1 = 0 ;
38225 char *kwnames[] = {
38226 (char *) "self",(char *) "flag", NULL
38227 };
38228
38229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
38230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38231 if (SWIG_arg_fail(1)) SWIG_fail;
38232 {
38233 arg2 = (int)(SWIG_As_int(obj1));
38234 if (SWIG_arg_fail(2)) SWIG_fail;
38235 }
38236 {
38237 PyThreadState* __tstate = wxPyBeginAllowThreads();
38238 (arg1)->SetFlag(arg2);
38239
38240 wxPyEndAllowThreads(__tstate);
38241 if (PyErr_Occurred()) SWIG_fail;
38242 }
38243 Py_INCREF(Py_None); resultobj = Py_None;
38244 return resultobj;
38245 fail:
38246 return NULL;
38247 }
38248
38249
38250 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38251 PyObject *resultobj;
38252 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38253 int result;
38254 PyObject * obj0 = 0 ;
38255 char *kwnames[] = {
38256 (char *) "self", NULL
38257 };
38258
38259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
38260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38261 if (SWIG_arg_fail(1)) SWIG_fail;
38262 {
38263 PyThreadState* __tstate = wxPyBeginAllowThreads();
38264 result = (int)(arg1)->GetFlag();
38265
38266 wxPyEndAllowThreads(__tstate);
38267 if (PyErr_Occurred()) SWIG_fail;
38268 }
38269 {
38270 resultobj = SWIG_From_int((int)(result));
38271 }
38272 return resultobj;
38273 fail:
38274 return NULL;
38275 }
38276
38277
38278 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38279 PyObject *resultobj;
38280 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38281 int arg2 ;
38282 PyObject * obj0 = 0 ;
38283 PyObject * obj1 = 0 ;
38284 char *kwnames[] = {
38285 (char *) "self",(char *) "border", NULL
38286 };
38287
38288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
38289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38290 if (SWIG_arg_fail(1)) SWIG_fail;
38291 {
38292 arg2 = (int)(SWIG_As_int(obj1));
38293 if (SWIG_arg_fail(2)) SWIG_fail;
38294 }
38295 {
38296 PyThreadState* __tstate = wxPyBeginAllowThreads();
38297 (arg1)->SetBorder(arg2);
38298
38299 wxPyEndAllowThreads(__tstate);
38300 if (PyErr_Occurred()) SWIG_fail;
38301 }
38302 Py_INCREF(Py_None); resultobj = Py_None;
38303 return resultobj;
38304 fail:
38305 return NULL;
38306 }
38307
38308
38309 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38310 PyObject *resultobj;
38311 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38312 int result;
38313 PyObject * obj0 = 0 ;
38314 char *kwnames[] = {
38315 (char *) "self", NULL
38316 };
38317
38318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
38319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38320 if (SWIG_arg_fail(1)) SWIG_fail;
38321 {
38322 PyThreadState* __tstate = wxPyBeginAllowThreads();
38323 result = (int)(arg1)->GetBorder();
38324
38325 wxPyEndAllowThreads(__tstate);
38326 if (PyErr_Occurred()) SWIG_fail;
38327 }
38328 {
38329 resultobj = SWIG_From_int((int)(result));
38330 }
38331 return resultobj;
38332 fail:
38333 return NULL;
38334 }
38335
38336
38337 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38338 PyObject *resultobj;
38339 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38340 wxWindow *result;
38341 PyObject * obj0 = 0 ;
38342 char *kwnames[] = {
38343 (char *) "self", NULL
38344 };
38345
38346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
38347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38348 if (SWIG_arg_fail(1)) SWIG_fail;
38349 {
38350 PyThreadState* __tstate = wxPyBeginAllowThreads();
38351 result = (wxWindow *)(arg1)->GetWindow();
38352
38353 wxPyEndAllowThreads(__tstate);
38354 if (PyErr_Occurred()) SWIG_fail;
38355 }
38356 {
38357 resultobj = wxPyMake_wxObject(result, 0);
38358 }
38359 return resultobj;
38360 fail:
38361 return NULL;
38362 }
38363
38364
38365 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38366 PyObject *resultobj;
38367 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38368 wxWindow *arg2 = (wxWindow *) 0 ;
38369 PyObject * obj0 = 0 ;
38370 PyObject * obj1 = 0 ;
38371 char *kwnames[] = {
38372 (char *) "self",(char *) "window", NULL
38373 };
38374
38375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
38376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38377 if (SWIG_arg_fail(1)) SWIG_fail;
38378 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38379 if (SWIG_arg_fail(2)) SWIG_fail;
38380 {
38381 PyThreadState* __tstate = wxPyBeginAllowThreads();
38382 (arg1)->SetWindow(arg2);
38383
38384 wxPyEndAllowThreads(__tstate);
38385 if (PyErr_Occurred()) SWIG_fail;
38386 }
38387 Py_INCREF(Py_None); resultobj = Py_None;
38388 return resultobj;
38389 fail:
38390 return NULL;
38391 }
38392
38393
38394 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38395 PyObject *resultobj;
38396 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38397 wxSizer *result;
38398 PyObject * obj0 = 0 ;
38399 char *kwnames[] = {
38400 (char *) "self", NULL
38401 };
38402
38403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
38404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38405 if (SWIG_arg_fail(1)) SWIG_fail;
38406 {
38407 PyThreadState* __tstate = wxPyBeginAllowThreads();
38408 result = (wxSizer *)(arg1)->GetSizer();
38409
38410 wxPyEndAllowThreads(__tstate);
38411 if (PyErr_Occurred()) SWIG_fail;
38412 }
38413 {
38414 resultobj = wxPyMake_wxSizer(result, 0);
38415 }
38416 return resultobj;
38417 fail:
38418 return NULL;
38419 }
38420
38421
38422 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38423 PyObject *resultobj;
38424 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38425 wxSizer *arg2 = (wxSizer *) 0 ;
38426 PyObject * obj0 = 0 ;
38427 PyObject * obj1 = 0 ;
38428 char *kwnames[] = {
38429 (char *) "self",(char *) "sizer", NULL
38430 };
38431
38432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
38433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38434 if (SWIG_arg_fail(1)) SWIG_fail;
38435 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38436 if (SWIG_arg_fail(2)) SWIG_fail;
38437 {
38438 PyThreadState* __tstate = wxPyBeginAllowThreads();
38439 (arg1)->SetSizer(arg2);
38440
38441 wxPyEndAllowThreads(__tstate);
38442 if (PyErr_Occurred()) SWIG_fail;
38443 }
38444 Py_INCREF(Py_None); resultobj = Py_None;
38445 return resultobj;
38446 fail:
38447 return NULL;
38448 }
38449
38450
38451 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38452 PyObject *resultobj;
38453 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38454 wxSize *result;
38455 PyObject * obj0 = 0 ;
38456 char *kwnames[] = {
38457 (char *) "self", NULL
38458 };
38459
38460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
38461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38462 if (SWIG_arg_fail(1)) SWIG_fail;
38463 {
38464 PyThreadState* __tstate = wxPyBeginAllowThreads();
38465 {
38466 wxSize const &_result_ref = (arg1)->GetSpacer();
38467 result = (wxSize *) &_result_ref;
38468 }
38469
38470 wxPyEndAllowThreads(__tstate);
38471 if (PyErr_Occurred()) SWIG_fail;
38472 }
38473 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
38474 return resultobj;
38475 fail:
38476 return NULL;
38477 }
38478
38479
38480 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38481 PyObject *resultobj;
38482 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38483 wxSize *arg2 = 0 ;
38484 wxSize temp2 ;
38485 PyObject * obj0 = 0 ;
38486 PyObject * obj1 = 0 ;
38487 char *kwnames[] = {
38488 (char *) "self",(char *) "size", NULL
38489 };
38490
38491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
38492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38493 if (SWIG_arg_fail(1)) SWIG_fail;
38494 {
38495 arg2 = &temp2;
38496 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38497 }
38498 {
38499 PyThreadState* __tstate = wxPyBeginAllowThreads();
38500 (arg1)->SetSpacer((wxSize const &)*arg2);
38501
38502 wxPyEndAllowThreads(__tstate);
38503 if (PyErr_Occurred()) SWIG_fail;
38504 }
38505 Py_INCREF(Py_None); resultobj = Py_None;
38506 return resultobj;
38507 fail:
38508 return NULL;
38509 }
38510
38511
38512 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
38513 PyObject *resultobj;
38514 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38515 bool arg2 ;
38516 PyObject * obj0 = 0 ;
38517 PyObject * obj1 = 0 ;
38518 char *kwnames[] = {
38519 (char *) "self",(char *) "show", NULL
38520 };
38521
38522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
38523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38524 if (SWIG_arg_fail(1)) SWIG_fail;
38525 {
38526 arg2 = (bool)(SWIG_As_bool(obj1));
38527 if (SWIG_arg_fail(2)) SWIG_fail;
38528 }
38529 {
38530 PyThreadState* __tstate = wxPyBeginAllowThreads();
38531 (arg1)->Show(arg2);
38532
38533 wxPyEndAllowThreads(__tstate);
38534 if (PyErr_Occurred()) SWIG_fail;
38535 }
38536 Py_INCREF(Py_None); resultobj = Py_None;
38537 return resultobj;
38538 fail:
38539 return NULL;
38540 }
38541
38542
38543 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
38544 PyObject *resultobj;
38545 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38546 bool result;
38547 PyObject * obj0 = 0 ;
38548 char *kwnames[] = {
38549 (char *) "self", NULL
38550 };
38551
38552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
38553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38554 if (SWIG_arg_fail(1)) SWIG_fail;
38555 {
38556 PyThreadState* __tstate = wxPyBeginAllowThreads();
38557 result = (bool)(arg1)->IsShown();
38558
38559 wxPyEndAllowThreads(__tstate);
38560 if (PyErr_Occurred()) SWIG_fail;
38561 }
38562 {
38563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38564 }
38565 return resultobj;
38566 fail:
38567 return NULL;
38568 }
38569
38570
38571 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38572 PyObject *resultobj;
38573 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38574 wxPoint result;
38575 PyObject * obj0 = 0 ;
38576 char *kwnames[] = {
38577 (char *) "self", NULL
38578 };
38579
38580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
38581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38582 if (SWIG_arg_fail(1)) SWIG_fail;
38583 {
38584 PyThreadState* __tstate = wxPyBeginAllowThreads();
38585 result = (arg1)->GetPosition();
38586
38587 wxPyEndAllowThreads(__tstate);
38588 if (PyErr_Occurred()) SWIG_fail;
38589 }
38590 {
38591 wxPoint * resultptr;
38592 resultptr = new wxPoint((wxPoint &)(result));
38593 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38594 }
38595 return resultobj;
38596 fail:
38597 return NULL;
38598 }
38599
38600
38601 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
38602 PyObject *resultobj;
38603 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38604 PyObject *result;
38605 PyObject * obj0 = 0 ;
38606 char *kwnames[] = {
38607 (char *) "self", NULL
38608 };
38609
38610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
38611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38612 if (SWIG_arg_fail(1)) SWIG_fail;
38613 {
38614 PyThreadState* __tstate = wxPyBeginAllowThreads();
38615 result = (PyObject *)wxSizerItem_GetUserData(arg1);
38616
38617 wxPyEndAllowThreads(__tstate);
38618 if (PyErr_Occurred()) SWIG_fail;
38619 }
38620 resultobj = result;
38621 return resultobj;
38622 fail:
38623 return NULL;
38624 }
38625
38626
38627 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
38628 PyObject *obj;
38629 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38630 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
38631 Py_INCREF(obj);
38632 return Py_BuildValue((char *)"");
38633 }
38634 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
38635 PyObject *resultobj;
38636 wxSizer *arg1 = (wxSizer *) 0 ;
38637 PyObject *arg2 = (PyObject *) 0 ;
38638 PyObject * obj0 = 0 ;
38639 PyObject * obj1 = 0 ;
38640 char *kwnames[] = {
38641 (char *) "self",(char *) "_self", NULL
38642 };
38643
38644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
38645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38646 if (SWIG_arg_fail(1)) SWIG_fail;
38647 arg2 = obj1;
38648 {
38649 PyThreadState* __tstate = wxPyBeginAllowThreads();
38650 wxSizer__setOORInfo(arg1,arg2);
38651
38652 wxPyEndAllowThreads(__tstate);
38653 if (PyErr_Occurred()) SWIG_fail;
38654 }
38655 Py_INCREF(Py_None); resultobj = Py_None;
38656 return resultobj;
38657 fail:
38658 return NULL;
38659 }
38660
38661
38662 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
38663 PyObject *resultobj;
38664 wxSizer *arg1 = (wxSizer *) 0 ;
38665 PyObject *arg2 = (PyObject *) 0 ;
38666 int arg3 = (int) 0 ;
38667 int arg4 = (int) 0 ;
38668 int arg5 = (int) 0 ;
38669 PyObject *arg6 = (PyObject *) NULL ;
38670 wxSizerItem *result;
38671 PyObject * obj0 = 0 ;
38672 PyObject * obj1 = 0 ;
38673 PyObject * obj2 = 0 ;
38674 PyObject * obj3 = 0 ;
38675 PyObject * obj4 = 0 ;
38676 PyObject * obj5 = 0 ;
38677 char *kwnames[] = {
38678 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38679 };
38680
38681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38683 if (SWIG_arg_fail(1)) SWIG_fail;
38684 arg2 = obj1;
38685 if (obj2) {
38686 {
38687 arg3 = (int)(SWIG_As_int(obj2));
38688 if (SWIG_arg_fail(3)) SWIG_fail;
38689 }
38690 }
38691 if (obj3) {
38692 {
38693 arg4 = (int)(SWIG_As_int(obj3));
38694 if (SWIG_arg_fail(4)) SWIG_fail;
38695 }
38696 }
38697 if (obj4) {
38698 {
38699 arg5 = (int)(SWIG_As_int(obj4));
38700 if (SWIG_arg_fail(5)) SWIG_fail;
38701 }
38702 }
38703 if (obj5) {
38704 arg6 = obj5;
38705 }
38706 {
38707 PyThreadState* __tstate = wxPyBeginAllowThreads();
38708 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
38709
38710 wxPyEndAllowThreads(__tstate);
38711 if (PyErr_Occurred()) SWIG_fail;
38712 }
38713 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38714 return resultobj;
38715 fail:
38716 return NULL;
38717 }
38718
38719
38720 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38721 PyObject *resultobj;
38722 wxSizer *arg1 = (wxSizer *) 0 ;
38723 int arg2 ;
38724 PyObject *arg3 = (PyObject *) 0 ;
38725 int arg4 = (int) 0 ;
38726 int arg5 = (int) 0 ;
38727 int arg6 = (int) 0 ;
38728 PyObject *arg7 = (PyObject *) NULL ;
38729 wxSizerItem *result;
38730 PyObject * obj0 = 0 ;
38731 PyObject * obj1 = 0 ;
38732 PyObject * obj2 = 0 ;
38733 PyObject * obj3 = 0 ;
38734 PyObject * obj4 = 0 ;
38735 PyObject * obj5 = 0 ;
38736 PyObject * obj6 = 0 ;
38737 char *kwnames[] = {
38738 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38739 };
38740
38741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38743 if (SWIG_arg_fail(1)) SWIG_fail;
38744 {
38745 arg2 = (int)(SWIG_As_int(obj1));
38746 if (SWIG_arg_fail(2)) SWIG_fail;
38747 }
38748 arg3 = obj2;
38749 if (obj3) {
38750 {
38751 arg4 = (int)(SWIG_As_int(obj3));
38752 if (SWIG_arg_fail(4)) SWIG_fail;
38753 }
38754 }
38755 if (obj4) {
38756 {
38757 arg5 = (int)(SWIG_As_int(obj4));
38758 if (SWIG_arg_fail(5)) SWIG_fail;
38759 }
38760 }
38761 if (obj5) {
38762 {
38763 arg6 = (int)(SWIG_As_int(obj5));
38764 if (SWIG_arg_fail(6)) SWIG_fail;
38765 }
38766 }
38767 if (obj6) {
38768 arg7 = obj6;
38769 }
38770 {
38771 PyThreadState* __tstate = wxPyBeginAllowThreads();
38772 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
38773
38774 wxPyEndAllowThreads(__tstate);
38775 if (PyErr_Occurred()) SWIG_fail;
38776 }
38777 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38778 return resultobj;
38779 fail:
38780 return NULL;
38781 }
38782
38783
38784 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
38785 PyObject *resultobj;
38786 wxSizer *arg1 = (wxSizer *) 0 ;
38787 PyObject *arg2 = (PyObject *) 0 ;
38788 int arg3 = (int) 0 ;
38789 int arg4 = (int) 0 ;
38790 int arg5 = (int) 0 ;
38791 PyObject *arg6 = (PyObject *) NULL ;
38792 wxSizerItem *result;
38793 PyObject * obj0 = 0 ;
38794 PyObject * obj1 = 0 ;
38795 PyObject * obj2 = 0 ;
38796 PyObject * obj3 = 0 ;
38797 PyObject * obj4 = 0 ;
38798 PyObject * obj5 = 0 ;
38799 char *kwnames[] = {
38800 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38801 };
38802
38803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38805 if (SWIG_arg_fail(1)) SWIG_fail;
38806 arg2 = obj1;
38807 if (obj2) {
38808 {
38809 arg3 = (int)(SWIG_As_int(obj2));
38810 if (SWIG_arg_fail(3)) SWIG_fail;
38811 }
38812 }
38813 if (obj3) {
38814 {
38815 arg4 = (int)(SWIG_As_int(obj3));
38816 if (SWIG_arg_fail(4)) SWIG_fail;
38817 }
38818 }
38819 if (obj4) {
38820 {
38821 arg5 = (int)(SWIG_As_int(obj4));
38822 if (SWIG_arg_fail(5)) SWIG_fail;
38823 }
38824 }
38825 if (obj5) {
38826 arg6 = obj5;
38827 }
38828 {
38829 PyThreadState* __tstate = wxPyBeginAllowThreads();
38830 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
38831
38832 wxPyEndAllowThreads(__tstate);
38833 if (PyErr_Occurred()) SWIG_fail;
38834 }
38835 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38836 return resultobj;
38837 fail:
38838 return NULL;
38839 }
38840
38841
38842 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
38843 PyObject *resultobj;
38844 wxSizer *arg1 = (wxSizer *) 0 ;
38845 PyObject *arg2 = (PyObject *) 0 ;
38846 bool result;
38847 PyObject * obj0 = 0 ;
38848 PyObject * obj1 = 0 ;
38849 char *kwnames[] = {
38850 (char *) "self",(char *) "item", NULL
38851 };
38852
38853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
38854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38855 if (SWIG_arg_fail(1)) SWIG_fail;
38856 arg2 = obj1;
38857 {
38858 PyThreadState* __tstate = wxPyBeginAllowThreads();
38859 result = (bool)wxSizer_Remove(arg1,arg2);
38860
38861 wxPyEndAllowThreads(__tstate);
38862 if (PyErr_Occurred()) SWIG_fail;
38863 }
38864 {
38865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38866 }
38867 return resultobj;
38868 fail:
38869 return NULL;
38870 }
38871
38872
38873 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
38874 PyObject *resultobj;
38875 wxSizer *arg1 = (wxSizer *) 0 ;
38876 PyObject *arg2 = (PyObject *) 0 ;
38877 bool result;
38878 PyObject * obj0 = 0 ;
38879 PyObject * obj1 = 0 ;
38880 char *kwnames[] = {
38881 (char *) "self",(char *) "item", NULL
38882 };
38883
38884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
38885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38886 if (SWIG_arg_fail(1)) SWIG_fail;
38887 arg2 = obj1;
38888 {
38889 PyThreadState* __tstate = wxPyBeginAllowThreads();
38890 result = (bool)wxSizer_Detach(arg1,arg2);
38891
38892 wxPyEndAllowThreads(__tstate);
38893 if (PyErr_Occurred()) SWIG_fail;
38894 }
38895 {
38896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38897 }
38898 return resultobj;
38899 fail:
38900 return NULL;
38901 }
38902
38903
38904 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
38905 PyObject *resultobj;
38906 wxSizer *arg1 = (wxSizer *) 0 ;
38907 PyObject *arg2 = (PyObject *) 0 ;
38908 wxSizerItem *result;
38909 PyObject * obj0 = 0 ;
38910 PyObject * obj1 = 0 ;
38911 char *kwnames[] = {
38912 (char *) "self",(char *) "item", NULL
38913 };
38914
38915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
38916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38917 if (SWIG_arg_fail(1)) SWIG_fail;
38918 arg2 = obj1;
38919 {
38920 PyThreadState* __tstate = wxPyBeginAllowThreads();
38921 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
38922
38923 wxPyEndAllowThreads(__tstate);
38924 if (PyErr_Occurred()) SWIG_fail;
38925 }
38926 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38927 return resultobj;
38928 fail:
38929 return NULL;
38930 }
38931
38932
38933 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38934 PyObject *resultobj;
38935 wxSizer *arg1 = (wxSizer *) 0 ;
38936 PyObject *arg2 = (PyObject *) 0 ;
38937 wxSize *arg3 = 0 ;
38938 wxSize temp3 ;
38939 PyObject * obj0 = 0 ;
38940 PyObject * obj1 = 0 ;
38941 PyObject * obj2 = 0 ;
38942 char *kwnames[] = {
38943 (char *) "self",(char *) "item",(char *) "size", NULL
38944 };
38945
38946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38948 if (SWIG_arg_fail(1)) SWIG_fail;
38949 arg2 = obj1;
38950 {
38951 arg3 = &temp3;
38952 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
38953 }
38954 {
38955 PyThreadState* __tstate = wxPyBeginAllowThreads();
38956 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
38957
38958 wxPyEndAllowThreads(__tstate);
38959 if (PyErr_Occurred()) SWIG_fail;
38960 }
38961 Py_INCREF(Py_None); resultobj = Py_None;
38962 return resultobj;
38963 fail:
38964 return NULL;
38965 }
38966
38967
38968 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
38969 PyObject *resultobj;
38970 wxSizer *arg1 = (wxSizer *) 0 ;
38971 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
38972 wxSizerItem *result;
38973 PyObject * obj0 = 0 ;
38974 PyObject * obj1 = 0 ;
38975 char *kwnames[] = {
38976 (char *) "self",(char *) "item", NULL
38977 };
38978
38979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
38980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38981 if (SWIG_arg_fail(1)) SWIG_fail;
38982 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38983 if (SWIG_arg_fail(2)) SWIG_fail;
38984 {
38985 PyThreadState* __tstate = wxPyBeginAllowThreads();
38986 result = (wxSizerItem *)(arg1)->Add(arg2);
38987
38988 wxPyEndAllowThreads(__tstate);
38989 if (PyErr_Occurred()) SWIG_fail;
38990 }
38991 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38992 return resultobj;
38993 fail:
38994 return NULL;
38995 }
38996
38997
38998 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
38999 PyObject *resultobj;
39000 wxSizer *arg1 = (wxSizer *) 0 ;
39001 size_t arg2 ;
39002 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39003 wxSizerItem *result;
39004 PyObject * obj0 = 0 ;
39005 PyObject * obj1 = 0 ;
39006 PyObject * obj2 = 0 ;
39007 char *kwnames[] = {
39008 (char *) "self",(char *) "index",(char *) "item", NULL
39009 };
39010
39011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39013 if (SWIG_arg_fail(1)) SWIG_fail;
39014 {
39015 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39016 if (SWIG_arg_fail(2)) SWIG_fail;
39017 }
39018 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39019 if (SWIG_arg_fail(3)) SWIG_fail;
39020 {
39021 PyThreadState* __tstate = wxPyBeginAllowThreads();
39022 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39023
39024 wxPyEndAllowThreads(__tstate);
39025 if (PyErr_Occurred()) SWIG_fail;
39026 }
39027 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39028 return resultobj;
39029 fail:
39030 return NULL;
39031 }
39032
39033
39034 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39035 PyObject *resultobj;
39036 wxSizer *arg1 = (wxSizer *) 0 ;
39037 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39038 wxSizerItem *result;
39039 PyObject * obj0 = 0 ;
39040 PyObject * obj1 = 0 ;
39041 char *kwnames[] = {
39042 (char *) "self",(char *) "item", NULL
39043 };
39044
39045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39047 if (SWIG_arg_fail(1)) SWIG_fail;
39048 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39049 if (SWIG_arg_fail(2)) SWIG_fail;
39050 {
39051 PyThreadState* __tstate = wxPyBeginAllowThreads();
39052 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39053
39054 wxPyEndAllowThreads(__tstate);
39055 if (PyErr_Occurred()) SWIG_fail;
39056 }
39057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39058 return resultobj;
39059 fail:
39060 return NULL;
39061 }
39062
39063
39064 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39065 PyObject *resultobj;
39066 wxSizer *arg1 = (wxSizer *) 0 ;
39067 int arg2 ;
39068 int arg3 ;
39069 int arg4 ;
39070 int arg5 ;
39071 PyObject * obj0 = 0 ;
39072 PyObject * obj1 = 0 ;
39073 PyObject * obj2 = 0 ;
39074 PyObject * obj3 = 0 ;
39075 PyObject * obj4 = 0 ;
39076 char *kwnames[] = {
39077 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39078 };
39079
39080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39082 if (SWIG_arg_fail(1)) SWIG_fail;
39083 {
39084 arg2 = (int)(SWIG_As_int(obj1));
39085 if (SWIG_arg_fail(2)) SWIG_fail;
39086 }
39087 {
39088 arg3 = (int)(SWIG_As_int(obj2));
39089 if (SWIG_arg_fail(3)) SWIG_fail;
39090 }
39091 {
39092 arg4 = (int)(SWIG_As_int(obj3));
39093 if (SWIG_arg_fail(4)) SWIG_fail;
39094 }
39095 {
39096 arg5 = (int)(SWIG_As_int(obj4));
39097 if (SWIG_arg_fail(5)) SWIG_fail;
39098 }
39099 {
39100 PyThreadState* __tstate = wxPyBeginAllowThreads();
39101 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39102
39103 wxPyEndAllowThreads(__tstate);
39104 if (PyErr_Occurred()) SWIG_fail;
39105 }
39106 Py_INCREF(Py_None); resultobj = Py_None;
39107 return resultobj;
39108 fail:
39109 return NULL;
39110 }
39111
39112
39113 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39114 PyObject *resultobj;
39115 wxSizer *arg1 = (wxSizer *) 0 ;
39116 wxSize *arg2 = 0 ;
39117 wxSize temp2 ;
39118 PyObject * obj0 = 0 ;
39119 PyObject * obj1 = 0 ;
39120 char *kwnames[] = {
39121 (char *) "self",(char *) "size", NULL
39122 };
39123
39124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
39125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39126 if (SWIG_arg_fail(1)) SWIG_fail;
39127 {
39128 arg2 = &temp2;
39129 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39130 }
39131 {
39132 PyThreadState* __tstate = wxPyBeginAllowThreads();
39133 (arg1)->SetMinSize((wxSize const &)*arg2);
39134
39135 wxPyEndAllowThreads(__tstate);
39136 if (PyErr_Occurred()) SWIG_fail;
39137 }
39138 Py_INCREF(Py_None); resultobj = Py_None;
39139 return resultobj;
39140 fail:
39141 return NULL;
39142 }
39143
39144
39145 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39146 PyObject *resultobj;
39147 wxSizer *arg1 = (wxSizer *) 0 ;
39148 wxSize result;
39149 PyObject * obj0 = 0 ;
39150 char *kwnames[] = {
39151 (char *) "self", NULL
39152 };
39153
39154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
39155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39156 if (SWIG_arg_fail(1)) SWIG_fail;
39157 {
39158 PyThreadState* __tstate = wxPyBeginAllowThreads();
39159 result = (arg1)->GetSize();
39160
39161 wxPyEndAllowThreads(__tstate);
39162 if (PyErr_Occurred()) SWIG_fail;
39163 }
39164 {
39165 wxSize * resultptr;
39166 resultptr = new wxSize((wxSize &)(result));
39167 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39168 }
39169 return resultobj;
39170 fail:
39171 return NULL;
39172 }
39173
39174
39175 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39176 PyObject *resultobj;
39177 wxSizer *arg1 = (wxSizer *) 0 ;
39178 wxPoint result;
39179 PyObject * obj0 = 0 ;
39180 char *kwnames[] = {
39181 (char *) "self", NULL
39182 };
39183
39184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
39185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39186 if (SWIG_arg_fail(1)) SWIG_fail;
39187 {
39188 PyThreadState* __tstate = wxPyBeginAllowThreads();
39189 result = (arg1)->GetPosition();
39190
39191 wxPyEndAllowThreads(__tstate);
39192 if (PyErr_Occurred()) SWIG_fail;
39193 }
39194 {
39195 wxPoint * resultptr;
39196 resultptr = new wxPoint((wxPoint &)(result));
39197 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39198 }
39199 return resultobj;
39200 fail:
39201 return NULL;
39202 }
39203
39204
39205 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39206 PyObject *resultobj;
39207 wxSizer *arg1 = (wxSizer *) 0 ;
39208 wxSize result;
39209 PyObject * obj0 = 0 ;
39210 char *kwnames[] = {
39211 (char *) "self", NULL
39212 };
39213
39214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
39215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39216 if (SWIG_arg_fail(1)) SWIG_fail;
39217 {
39218 PyThreadState* __tstate = wxPyBeginAllowThreads();
39219 result = (arg1)->GetMinSize();
39220
39221 wxPyEndAllowThreads(__tstate);
39222 if (PyErr_Occurred()) SWIG_fail;
39223 }
39224 {
39225 wxSize * resultptr;
39226 resultptr = new wxSize((wxSize &)(result));
39227 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39228 }
39229 return resultobj;
39230 fail:
39231 return NULL;
39232 }
39233
39234
39235 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
39236 PyObject *resultobj;
39237 wxSizer *arg1 = (wxSizer *) 0 ;
39238 PyObject * obj0 = 0 ;
39239 char *kwnames[] = {
39240 (char *) "self", NULL
39241 };
39242
39243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
39244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39245 if (SWIG_arg_fail(1)) SWIG_fail;
39246 {
39247 PyThreadState* __tstate = wxPyBeginAllowThreads();
39248 (arg1)->RecalcSizes();
39249
39250 wxPyEndAllowThreads(__tstate);
39251 if (PyErr_Occurred()) SWIG_fail;
39252 }
39253 Py_INCREF(Py_None); resultobj = Py_None;
39254 return resultobj;
39255 fail:
39256 return NULL;
39257 }
39258
39259
39260 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39261 PyObject *resultobj;
39262 wxSizer *arg1 = (wxSizer *) 0 ;
39263 wxSize result;
39264 PyObject * obj0 = 0 ;
39265 char *kwnames[] = {
39266 (char *) "self", NULL
39267 };
39268
39269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
39270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39271 if (SWIG_arg_fail(1)) SWIG_fail;
39272 {
39273 PyThreadState* __tstate = wxPyBeginAllowThreads();
39274 result = (arg1)->CalcMin();
39275
39276 wxPyEndAllowThreads(__tstate);
39277 if (PyErr_Occurred()) SWIG_fail;
39278 }
39279 {
39280 wxSize * resultptr;
39281 resultptr = new wxSize((wxSize &)(result));
39282 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39283 }
39284 return resultobj;
39285 fail:
39286 return NULL;
39287 }
39288
39289
39290 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
39291 PyObject *resultobj;
39292 wxSizer *arg1 = (wxSizer *) 0 ;
39293 PyObject * obj0 = 0 ;
39294 char *kwnames[] = {
39295 (char *) "self", NULL
39296 };
39297
39298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
39299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39300 if (SWIG_arg_fail(1)) SWIG_fail;
39301 {
39302 PyThreadState* __tstate = wxPyBeginAllowThreads();
39303 (arg1)->Layout();
39304
39305 wxPyEndAllowThreads(__tstate);
39306 if (PyErr_Occurred()) SWIG_fail;
39307 }
39308 Py_INCREF(Py_None); resultobj = Py_None;
39309 return resultobj;
39310 fail:
39311 return NULL;
39312 }
39313
39314
39315 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
39316 PyObject *resultobj;
39317 wxSizer *arg1 = (wxSizer *) 0 ;
39318 wxWindow *arg2 = (wxWindow *) 0 ;
39319 wxSize result;
39320 PyObject * obj0 = 0 ;
39321 PyObject * obj1 = 0 ;
39322 char *kwnames[] = {
39323 (char *) "self",(char *) "window", NULL
39324 };
39325
39326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
39327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39328 if (SWIG_arg_fail(1)) SWIG_fail;
39329 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39330 if (SWIG_arg_fail(2)) SWIG_fail;
39331 {
39332 PyThreadState* __tstate = wxPyBeginAllowThreads();
39333 result = (arg1)->Fit(arg2);
39334
39335 wxPyEndAllowThreads(__tstate);
39336 if (PyErr_Occurred()) SWIG_fail;
39337 }
39338 {
39339 wxSize * resultptr;
39340 resultptr = new wxSize((wxSize &)(result));
39341 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39342 }
39343 return resultobj;
39344 fail:
39345 return NULL;
39346 }
39347
39348
39349 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
39350 PyObject *resultobj;
39351 wxSizer *arg1 = (wxSizer *) 0 ;
39352 wxWindow *arg2 = (wxWindow *) 0 ;
39353 PyObject * obj0 = 0 ;
39354 PyObject * obj1 = 0 ;
39355 char *kwnames[] = {
39356 (char *) "self",(char *) "window", NULL
39357 };
39358
39359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
39360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39361 if (SWIG_arg_fail(1)) SWIG_fail;
39362 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39363 if (SWIG_arg_fail(2)) SWIG_fail;
39364 {
39365 PyThreadState* __tstate = wxPyBeginAllowThreads();
39366 (arg1)->FitInside(arg2);
39367
39368 wxPyEndAllowThreads(__tstate);
39369 if (PyErr_Occurred()) SWIG_fail;
39370 }
39371 Py_INCREF(Py_None); resultobj = Py_None;
39372 return resultobj;
39373 fail:
39374 return NULL;
39375 }
39376
39377
39378 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39379 PyObject *resultobj;
39380 wxSizer *arg1 = (wxSizer *) 0 ;
39381 wxWindow *arg2 = (wxWindow *) 0 ;
39382 PyObject * obj0 = 0 ;
39383 PyObject * obj1 = 0 ;
39384 char *kwnames[] = {
39385 (char *) "self",(char *) "window", NULL
39386 };
39387
39388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
39389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39390 if (SWIG_arg_fail(1)) SWIG_fail;
39391 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39392 if (SWIG_arg_fail(2)) SWIG_fail;
39393 {
39394 PyThreadState* __tstate = wxPyBeginAllowThreads();
39395 (arg1)->SetSizeHints(arg2);
39396
39397 wxPyEndAllowThreads(__tstate);
39398 if (PyErr_Occurred()) SWIG_fail;
39399 }
39400 Py_INCREF(Py_None); resultobj = Py_None;
39401 return resultobj;
39402 fail:
39403 return NULL;
39404 }
39405
39406
39407 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39408 PyObject *resultobj;
39409 wxSizer *arg1 = (wxSizer *) 0 ;
39410 wxWindow *arg2 = (wxWindow *) 0 ;
39411 PyObject * obj0 = 0 ;
39412 PyObject * obj1 = 0 ;
39413 char *kwnames[] = {
39414 (char *) "self",(char *) "window", NULL
39415 };
39416
39417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
39418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39419 if (SWIG_arg_fail(1)) SWIG_fail;
39420 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39421 if (SWIG_arg_fail(2)) SWIG_fail;
39422 {
39423 PyThreadState* __tstate = wxPyBeginAllowThreads();
39424 (arg1)->SetVirtualSizeHints(arg2);
39425
39426 wxPyEndAllowThreads(__tstate);
39427 if (PyErr_Occurred()) SWIG_fail;
39428 }
39429 Py_INCREF(Py_None); resultobj = Py_None;
39430 return resultobj;
39431 fail:
39432 return NULL;
39433 }
39434
39435
39436 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
39437 PyObject *resultobj;
39438 wxSizer *arg1 = (wxSizer *) 0 ;
39439 bool arg2 = (bool) false ;
39440 PyObject * obj0 = 0 ;
39441 PyObject * obj1 = 0 ;
39442 char *kwnames[] = {
39443 (char *) "self",(char *) "deleteWindows", NULL
39444 };
39445
39446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
39447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39448 if (SWIG_arg_fail(1)) SWIG_fail;
39449 if (obj1) {
39450 {
39451 arg2 = (bool)(SWIG_As_bool(obj1));
39452 if (SWIG_arg_fail(2)) SWIG_fail;
39453 }
39454 }
39455 {
39456 PyThreadState* __tstate = wxPyBeginAllowThreads();
39457 (arg1)->Clear(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_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39470 PyObject *resultobj;
39471 wxSizer *arg1 = (wxSizer *) 0 ;
39472 PyObject * obj0 = 0 ;
39473 char *kwnames[] = {
39474 (char *) "self", NULL
39475 };
39476
39477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
39478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39479 if (SWIG_arg_fail(1)) SWIG_fail;
39480 {
39481 PyThreadState* __tstate = wxPyBeginAllowThreads();
39482 (arg1)->DeleteWindows();
39483
39484 wxPyEndAllowThreads(__tstate);
39485 if (PyErr_Occurred()) SWIG_fail;
39486 }
39487 Py_INCREF(Py_None); resultobj = Py_None;
39488 return resultobj;
39489 fail:
39490 return NULL;
39491 }
39492
39493
39494 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
39495 PyObject *resultobj;
39496 wxSizer *arg1 = (wxSizer *) 0 ;
39497 PyObject *result;
39498 PyObject * obj0 = 0 ;
39499 char *kwnames[] = {
39500 (char *) "self", NULL
39501 };
39502
39503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
39504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39505 if (SWIG_arg_fail(1)) SWIG_fail;
39506 {
39507 PyThreadState* __tstate = wxPyBeginAllowThreads();
39508 result = (PyObject *)wxSizer_GetChildren(arg1);
39509
39510 wxPyEndAllowThreads(__tstate);
39511 if (PyErr_Occurred()) SWIG_fail;
39512 }
39513 resultobj = result;
39514 return resultobj;
39515 fail:
39516 return NULL;
39517 }
39518
39519
39520 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39521 PyObject *resultobj;
39522 wxSizer *arg1 = (wxSizer *) 0 ;
39523 PyObject *arg2 = (PyObject *) 0 ;
39524 bool arg3 = (bool) true ;
39525 bool arg4 = (bool) false ;
39526 bool result;
39527 PyObject * obj0 = 0 ;
39528 PyObject * obj1 = 0 ;
39529 PyObject * obj2 = 0 ;
39530 PyObject * obj3 = 0 ;
39531 char *kwnames[] = {
39532 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
39533 };
39534
39535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39537 if (SWIG_arg_fail(1)) SWIG_fail;
39538 arg2 = obj1;
39539 if (obj2) {
39540 {
39541 arg3 = (bool)(SWIG_As_bool(obj2));
39542 if (SWIG_arg_fail(3)) SWIG_fail;
39543 }
39544 }
39545 if (obj3) {
39546 {
39547 arg4 = (bool)(SWIG_As_bool(obj3));
39548 if (SWIG_arg_fail(4)) SWIG_fail;
39549 }
39550 }
39551 {
39552 PyThreadState* __tstate = wxPyBeginAllowThreads();
39553 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
39554
39555 wxPyEndAllowThreads(__tstate);
39556 if (PyErr_Occurred()) SWIG_fail;
39557 }
39558 {
39559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39560 }
39561 return resultobj;
39562 fail:
39563 return NULL;
39564 }
39565
39566
39567 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39568 PyObject *resultobj;
39569 wxSizer *arg1 = (wxSizer *) 0 ;
39570 PyObject *arg2 = (PyObject *) 0 ;
39571 bool result;
39572 PyObject * obj0 = 0 ;
39573 PyObject * obj1 = 0 ;
39574 char *kwnames[] = {
39575 (char *) "self",(char *) "item", NULL
39576 };
39577
39578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
39579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39580 if (SWIG_arg_fail(1)) SWIG_fail;
39581 arg2 = obj1;
39582 {
39583 PyThreadState* __tstate = wxPyBeginAllowThreads();
39584 result = (bool)wxSizer_IsShown(arg1,arg2);
39585
39586 wxPyEndAllowThreads(__tstate);
39587 if (PyErr_Occurred()) SWIG_fail;
39588 }
39589 {
39590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39591 }
39592 return resultobj;
39593 fail:
39594 return NULL;
39595 }
39596
39597
39598 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
39599 PyObject *resultobj;
39600 wxSizer *arg1 = (wxSizer *) 0 ;
39601 bool arg2 ;
39602 PyObject * obj0 = 0 ;
39603 PyObject * obj1 = 0 ;
39604 char *kwnames[] = {
39605 (char *) "self",(char *) "show", NULL
39606 };
39607
39608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
39609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39610 if (SWIG_arg_fail(1)) SWIG_fail;
39611 {
39612 arg2 = (bool)(SWIG_As_bool(obj1));
39613 if (SWIG_arg_fail(2)) SWIG_fail;
39614 }
39615 {
39616 PyThreadState* __tstate = wxPyBeginAllowThreads();
39617 (arg1)->ShowItems(arg2);
39618
39619 wxPyEndAllowThreads(__tstate);
39620 if (PyErr_Occurred()) SWIG_fail;
39621 }
39622 Py_INCREF(Py_None); resultobj = Py_None;
39623 return resultobj;
39624 fail:
39625 return NULL;
39626 }
39627
39628
39629 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
39630 PyObject *obj;
39631 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39632 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
39633 Py_INCREF(obj);
39634 return Py_BuildValue((char *)"");
39635 }
39636 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
39637 PyObject *resultobj;
39638 wxPySizer *result;
39639 char *kwnames[] = {
39640 NULL
39641 };
39642
39643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
39644 {
39645 PyThreadState* __tstate = wxPyBeginAllowThreads();
39646 result = (wxPySizer *)new wxPySizer();
39647
39648 wxPyEndAllowThreads(__tstate);
39649 if (PyErr_Occurred()) SWIG_fail;
39650 }
39651 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
39652 return resultobj;
39653 fail:
39654 return NULL;
39655 }
39656
39657
39658 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39659 PyObject *resultobj;
39660 wxPySizer *arg1 = (wxPySizer *) 0 ;
39661 PyObject *arg2 = (PyObject *) 0 ;
39662 PyObject *arg3 = (PyObject *) 0 ;
39663 PyObject * obj0 = 0 ;
39664 PyObject * obj1 = 0 ;
39665 PyObject * obj2 = 0 ;
39666 char *kwnames[] = {
39667 (char *) "self",(char *) "self",(char *) "_class", NULL
39668 };
39669
39670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
39671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
39672 if (SWIG_arg_fail(1)) SWIG_fail;
39673 arg2 = obj1;
39674 arg3 = obj2;
39675 {
39676 PyThreadState* __tstate = wxPyBeginAllowThreads();
39677 (arg1)->_setCallbackInfo(arg2,arg3);
39678
39679 wxPyEndAllowThreads(__tstate);
39680 if (PyErr_Occurred()) SWIG_fail;
39681 }
39682 Py_INCREF(Py_None); resultobj = Py_None;
39683 return resultobj;
39684 fail:
39685 return NULL;
39686 }
39687
39688
39689 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
39690 PyObject *obj;
39691 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39692 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
39693 Py_INCREF(obj);
39694 return Py_BuildValue((char *)"");
39695 }
39696 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39697 PyObject *resultobj;
39698 int arg1 = (int) wxHORIZONTAL ;
39699 wxBoxSizer *result;
39700 PyObject * obj0 = 0 ;
39701 char *kwnames[] = {
39702 (char *) "orient", NULL
39703 };
39704
39705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
39706 if (obj0) {
39707 {
39708 arg1 = (int)(SWIG_As_int(obj0));
39709 if (SWIG_arg_fail(1)) SWIG_fail;
39710 }
39711 }
39712 {
39713 PyThreadState* __tstate = wxPyBeginAllowThreads();
39714 result = (wxBoxSizer *)new wxBoxSizer(arg1);
39715
39716 wxPyEndAllowThreads(__tstate);
39717 if (PyErr_Occurred()) SWIG_fail;
39718 }
39719 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
39720 return resultobj;
39721 fail:
39722 return NULL;
39723 }
39724
39725
39726 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
39727 PyObject *resultobj;
39728 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
39729 int result;
39730 PyObject * obj0 = 0 ;
39731 char *kwnames[] = {
39732 (char *) "self", NULL
39733 };
39734
39735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
39736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39737 if (SWIG_arg_fail(1)) SWIG_fail;
39738 {
39739 PyThreadState* __tstate = wxPyBeginAllowThreads();
39740 result = (int)(arg1)->GetOrientation();
39741
39742 wxPyEndAllowThreads(__tstate);
39743 if (PyErr_Occurred()) SWIG_fail;
39744 }
39745 {
39746 resultobj = SWIG_From_int((int)(result));
39747 }
39748 return resultobj;
39749 fail:
39750 return NULL;
39751 }
39752
39753
39754 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
39755 PyObject *resultobj;
39756 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
39757 int arg2 ;
39758 PyObject * obj0 = 0 ;
39759 PyObject * obj1 = 0 ;
39760 char *kwnames[] = {
39761 (char *) "self",(char *) "orient", NULL
39762 };
39763
39764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
39765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39766 if (SWIG_arg_fail(1)) SWIG_fail;
39767 {
39768 arg2 = (int)(SWIG_As_int(obj1));
39769 if (SWIG_arg_fail(2)) SWIG_fail;
39770 }
39771 {
39772 PyThreadState* __tstate = wxPyBeginAllowThreads();
39773 (arg1)->SetOrientation(arg2);
39774
39775 wxPyEndAllowThreads(__tstate);
39776 if (PyErr_Occurred()) SWIG_fail;
39777 }
39778 Py_INCREF(Py_None); resultobj = Py_None;
39779 return resultobj;
39780 fail:
39781 return NULL;
39782 }
39783
39784
39785 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
39786 PyObject *obj;
39787 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39788 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
39789 Py_INCREF(obj);
39790 return Py_BuildValue((char *)"");
39791 }
39792 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39793 PyObject *resultobj;
39794 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
39795 int arg2 = (int) wxHORIZONTAL ;
39796 wxStaticBoxSizer *result;
39797 PyObject * obj0 = 0 ;
39798 PyObject * obj1 = 0 ;
39799 char *kwnames[] = {
39800 (char *) "box",(char *) "orient", NULL
39801 };
39802
39803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
39804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
39805 if (SWIG_arg_fail(1)) SWIG_fail;
39806 if (obj1) {
39807 {
39808 arg2 = (int)(SWIG_As_int(obj1));
39809 if (SWIG_arg_fail(2)) SWIG_fail;
39810 }
39811 }
39812 {
39813 PyThreadState* __tstate = wxPyBeginAllowThreads();
39814 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
39815
39816 wxPyEndAllowThreads(__tstate);
39817 if (PyErr_Occurred()) SWIG_fail;
39818 }
39819 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
39820 return resultobj;
39821 fail:
39822 return NULL;
39823 }
39824
39825
39826 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
39827 PyObject *resultobj;
39828 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
39829 wxStaticBox *result;
39830 PyObject * obj0 = 0 ;
39831 char *kwnames[] = {
39832 (char *) "self", NULL
39833 };
39834
39835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
39836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39837 if (SWIG_arg_fail(1)) SWIG_fail;
39838 {
39839 PyThreadState* __tstate = wxPyBeginAllowThreads();
39840 result = (wxStaticBox *)(arg1)->GetStaticBox();
39841
39842 wxPyEndAllowThreads(__tstate);
39843 if (PyErr_Occurred()) SWIG_fail;
39844 }
39845 {
39846 resultobj = wxPyMake_wxObject(result, 0);
39847 }
39848 return resultobj;
39849 fail:
39850 return NULL;
39851 }
39852
39853
39854 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
39855 PyObject *obj;
39856 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39857 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
39858 Py_INCREF(obj);
39859 return Py_BuildValue((char *)"");
39860 }
39861 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39862 PyObject *resultobj;
39863 int arg1 = (int) 1 ;
39864 int arg2 = (int) 0 ;
39865 int arg3 = (int) 0 ;
39866 int arg4 = (int) 0 ;
39867 wxGridSizer *result;
39868 PyObject * obj0 = 0 ;
39869 PyObject * obj1 = 0 ;
39870 PyObject * obj2 = 0 ;
39871 PyObject * obj3 = 0 ;
39872 char *kwnames[] = {
39873 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
39874 };
39875
39876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39877 if (obj0) {
39878 {
39879 arg1 = (int)(SWIG_As_int(obj0));
39880 if (SWIG_arg_fail(1)) SWIG_fail;
39881 }
39882 }
39883 if (obj1) {
39884 {
39885 arg2 = (int)(SWIG_As_int(obj1));
39886 if (SWIG_arg_fail(2)) SWIG_fail;
39887 }
39888 }
39889 if (obj2) {
39890 {
39891 arg3 = (int)(SWIG_As_int(obj2));
39892 if (SWIG_arg_fail(3)) SWIG_fail;
39893 }
39894 }
39895 if (obj3) {
39896 {
39897 arg4 = (int)(SWIG_As_int(obj3));
39898 if (SWIG_arg_fail(4)) SWIG_fail;
39899 }
39900 }
39901 {
39902 PyThreadState* __tstate = wxPyBeginAllowThreads();
39903 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
39904
39905 wxPyEndAllowThreads(__tstate);
39906 if (PyErr_Occurred()) SWIG_fail;
39907 }
39908 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
39909 return resultobj;
39910 fail:
39911 return NULL;
39912 }
39913
39914
39915 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
39916 PyObject *resultobj;
39917 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39918 int arg2 ;
39919 PyObject * obj0 = 0 ;
39920 PyObject * obj1 = 0 ;
39921 char *kwnames[] = {
39922 (char *) "self",(char *) "cols", NULL
39923 };
39924
39925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
39926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39927 if (SWIG_arg_fail(1)) SWIG_fail;
39928 {
39929 arg2 = (int)(SWIG_As_int(obj1));
39930 if (SWIG_arg_fail(2)) SWIG_fail;
39931 }
39932 {
39933 PyThreadState* __tstate = wxPyBeginAllowThreads();
39934 (arg1)->SetCols(arg2);
39935
39936 wxPyEndAllowThreads(__tstate);
39937 if (PyErr_Occurred()) SWIG_fail;
39938 }
39939 Py_INCREF(Py_None); resultobj = Py_None;
39940 return resultobj;
39941 fail:
39942 return NULL;
39943 }
39944
39945
39946 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
39947 PyObject *resultobj;
39948 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39949 int arg2 ;
39950 PyObject * obj0 = 0 ;
39951 PyObject * obj1 = 0 ;
39952 char *kwnames[] = {
39953 (char *) "self",(char *) "rows", NULL
39954 };
39955
39956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
39957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39958 if (SWIG_arg_fail(1)) SWIG_fail;
39959 {
39960 arg2 = (int)(SWIG_As_int(obj1));
39961 if (SWIG_arg_fail(2)) SWIG_fail;
39962 }
39963 {
39964 PyThreadState* __tstate = wxPyBeginAllowThreads();
39965 (arg1)->SetRows(arg2);
39966
39967 wxPyEndAllowThreads(__tstate);
39968 if (PyErr_Occurred()) SWIG_fail;
39969 }
39970 Py_INCREF(Py_None); resultobj = Py_None;
39971 return resultobj;
39972 fail:
39973 return NULL;
39974 }
39975
39976
39977 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
39978 PyObject *resultobj;
39979 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39980 int arg2 ;
39981 PyObject * obj0 = 0 ;
39982 PyObject * obj1 = 0 ;
39983 char *kwnames[] = {
39984 (char *) "self",(char *) "gap", NULL
39985 };
39986
39987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
39988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39989 if (SWIG_arg_fail(1)) SWIG_fail;
39990 {
39991 arg2 = (int)(SWIG_As_int(obj1));
39992 if (SWIG_arg_fail(2)) SWIG_fail;
39993 }
39994 {
39995 PyThreadState* __tstate = wxPyBeginAllowThreads();
39996 (arg1)->SetVGap(arg2);
39997
39998 wxPyEndAllowThreads(__tstate);
39999 if (PyErr_Occurred()) SWIG_fail;
40000 }
40001 Py_INCREF(Py_None); resultobj = Py_None;
40002 return resultobj;
40003 fail:
40004 return NULL;
40005 }
40006
40007
40008 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40009 PyObject *resultobj;
40010 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40011 int arg2 ;
40012 PyObject * obj0 = 0 ;
40013 PyObject * obj1 = 0 ;
40014 char *kwnames[] = {
40015 (char *) "self",(char *) "gap", NULL
40016 };
40017
40018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40020 if (SWIG_arg_fail(1)) SWIG_fail;
40021 {
40022 arg2 = (int)(SWIG_As_int(obj1));
40023 if (SWIG_arg_fail(2)) SWIG_fail;
40024 }
40025 {
40026 PyThreadState* __tstate = wxPyBeginAllowThreads();
40027 (arg1)->SetHGap(arg2);
40028
40029 wxPyEndAllowThreads(__tstate);
40030 if (PyErr_Occurred()) SWIG_fail;
40031 }
40032 Py_INCREF(Py_None); resultobj = Py_None;
40033 return resultobj;
40034 fail:
40035 return NULL;
40036 }
40037
40038
40039 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40040 PyObject *resultobj;
40041 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40042 int result;
40043 PyObject * obj0 = 0 ;
40044 char *kwnames[] = {
40045 (char *) "self", NULL
40046 };
40047
40048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40050 if (SWIG_arg_fail(1)) SWIG_fail;
40051 {
40052 PyThreadState* __tstate = wxPyBeginAllowThreads();
40053 result = (int)(arg1)->GetCols();
40054
40055 wxPyEndAllowThreads(__tstate);
40056 if (PyErr_Occurred()) SWIG_fail;
40057 }
40058 {
40059 resultobj = SWIG_From_int((int)(result));
40060 }
40061 return resultobj;
40062 fail:
40063 return NULL;
40064 }
40065
40066
40067 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40068 PyObject *resultobj;
40069 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40070 int result;
40071 PyObject * obj0 = 0 ;
40072 char *kwnames[] = {
40073 (char *) "self", NULL
40074 };
40075
40076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40078 if (SWIG_arg_fail(1)) SWIG_fail;
40079 {
40080 PyThreadState* __tstate = wxPyBeginAllowThreads();
40081 result = (int)(arg1)->GetRows();
40082
40083 wxPyEndAllowThreads(__tstate);
40084 if (PyErr_Occurred()) SWIG_fail;
40085 }
40086 {
40087 resultobj = SWIG_From_int((int)(result));
40088 }
40089 return resultobj;
40090 fail:
40091 return NULL;
40092 }
40093
40094
40095 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40096 PyObject *resultobj;
40097 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40098 int result;
40099 PyObject * obj0 = 0 ;
40100 char *kwnames[] = {
40101 (char *) "self", NULL
40102 };
40103
40104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40106 if (SWIG_arg_fail(1)) SWIG_fail;
40107 {
40108 PyThreadState* __tstate = wxPyBeginAllowThreads();
40109 result = (int)(arg1)->GetVGap();
40110
40111 wxPyEndAllowThreads(__tstate);
40112 if (PyErr_Occurred()) SWIG_fail;
40113 }
40114 {
40115 resultobj = SWIG_From_int((int)(result));
40116 }
40117 return resultobj;
40118 fail:
40119 return NULL;
40120 }
40121
40122
40123 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40124 PyObject *resultobj;
40125 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40126 int result;
40127 PyObject * obj0 = 0 ;
40128 char *kwnames[] = {
40129 (char *) "self", NULL
40130 };
40131
40132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
40133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40134 if (SWIG_arg_fail(1)) SWIG_fail;
40135 {
40136 PyThreadState* __tstate = wxPyBeginAllowThreads();
40137 result = (int)(arg1)->GetHGap();
40138
40139 wxPyEndAllowThreads(__tstate);
40140 if (PyErr_Occurred()) SWIG_fail;
40141 }
40142 {
40143 resultobj = SWIG_From_int((int)(result));
40144 }
40145 return resultobj;
40146 fail:
40147 return NULL;
40148 }
40149
40150
40151 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
40152 PyObject *obj;
40153 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40154 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
40155 Py_INCREF(obj);
40156 return Py_BuildValue((char *)"");
40157 }
40158 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40159 PyObject *resultobj;
40160 int arg1 = (int) 1 ;
40161 int arg2 = (int) 0 ;
40162 int arg3 = (int) 0 ;
40163 int arg4 = (int) 0 ;
40164 wxFlexGridSizer *result;
40165 PyObject * obj0 = 0 ;
40166 PyObject * obj1 = 0 ;
40167 PyObject * obj2 = 0 ;
40168 PyObject * obj3 = 0 ;
40169 char *kwnames[] = {
40170 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40171 };
40172
40173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40174 if (obj0) {
40175 {
40176 arg1 = (int)(SWIG_As_int(obj0));
40177 if (SWIG_arg_fail(1)) SWIG_fail;
40178 }
40179 }
40180 if (obj1) {
40181 {
40182 arg2 = (int)(SWIG_As_int(obj1));
40183 if (SWIG_arg_fail(2)) SWIG_fail;
40184 }
40185 }
40186 if (obj2) {
40187 {
40188 arg3 = (int)(SWIG_As_int(obj2));
40189 if (SWIG_arg_fail(3)) SWIG_fail;
40190 }
40191 }
40192 if (obj3) {
40193 {
40194 arg4 = (int)(SWIG_As_int(obj3));
40195 if (SWIG_arg_fail(4)) SWIG_fail;
40196 }
40197 }
40198 {
40199 PyThreadState* __tstate = wxPyBeginAllowThreads();
40200 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
40201
40202 wxPyEndAllowThreads(__tstate);
40203 if (PyErr_Occurred()) SWIG_fail;
40204 }
40205 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
40206 return resultobj;
40207 fail:
40208 return NULL;
40209 }
40210
40211
40212 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40213 PyObject *resultobj;
40214 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40215 size_t arg2 ;
40216 int arg3 = (int) 0 ;
40217 PyObject * obj0 = 0 ;
40218 PyObject * obj1 = 0 ;
40219 PyObject * obj2 = 0 ;
40220 char *kwnames[] = {
40221 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40222 };
40223
40224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
40225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40226 if (SWIG_arg_fail(1)) SWIG_fail;
40227 {
40228 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40229 if (SWIG_arg_fail(2)) SWIG_fail;
40230 }
40231 if (obj2) {
40232 {
40233 arg3 = (int)(SWIG_As_int(obj2));
40234 if (SWIG_arg_fail(3)) SWIG_fail;
40235 }
40236 }
40237 {
40238 PyThreadState* __tstate = wxPyBeginAllowThreads();
40239 (arg1)->AddGrowableRow(arg2,arg3);
40240
40241 wxPyEndAllowThreads(__tstate);
40242 if (PyErr_Occurred()) SWIG_fail;
40243 }
40244 Py_INCREF(Py_None); resultobj = Py_None;
40245 return resultobj;
40246 fail:
40247 return NULL;
40248 }
40249
40250
40251 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40252 PyObject *resultobj;
40253 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40254 size_t arg2 ;
40255 PyObject * obj0 = 0 ;
40256 PyObject * obj1 = 0 ;
40257 char *kwnames[] = {
40258 (char *) "self",(char *) "idx", NULL
40259 };
40260
40261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
40262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40263 if (SWIG_arg_fail(1)) SWIG_fail;
40264 {
40265 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40266 if (SWIG_arg_fail(2)) SWIG_fail;
40267 }
40268 {
40269 PyThreadState* __tstate = wxPyBeginAllowThreads();
40270 (arg1)->RemoveGrowableRow(arg2);
40271
40272 wxPyEndAllowThreads(__tstate);
40273 if (PyErr_Occurred()) SWIG_fail;
40274 }
40275 Py_INCREF(Py_None); resultobj = Py_None;
40276 return resultobj;
40277 fail:
40278 return NULL;
40279 }
40280
40281
40282 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40283 PyObject *resultobj;
40284 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40285 size_t arg2 ;
40286 int arg3 = (int) 0 ;
40287 PyObject * obj0 = 0 ;
40288 PyObject * obj1 = 0 ;
40289 PyObject * obj2 = 0 ;
40290 char *kwnames[] = {
40291 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40292 };
40293
40294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
40295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40296 if (SWIG_arg_fail(1)) SWIG_fail;
40297 {
40298 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40299 if (SWIG_arg_fail(2)) SWIG_fail;
40300 }
40301 if (obj2) {
40302 {
40303 arg3 = (int)(SWIG_As_int(obj2));
40304 if (SWIG_arg_fail(3)) SWIG_fail;
40305 }
40306 }
40307 {
40308 PyThreadState* __tstate = wxPyBeginAllowThreads();
40309 (arg1)->AddGrowableCol(arg2,arg3);
40310
40311 wxPyEndAllowThreads(__tstate);
40312 if (PyErr_Occurred()) SWIG_fail;
40313 }
40314 Py_INCREF(Py_None); resultobj = Py_None;
40315 return resultobj;
40316 fail:
40317 return NULL;
40318 }
40319
40320
40321 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40322 PyObject *resultobj;
40323 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40324 size_t arg2 ;
40325 PyObject * obj0 = 0 ;
40326 PyObject * obj1 = 0 ;
40327 char *kwnames[] = {
40328 (char *) "self",(char *) "idx", NULL
40329 };
40330
40331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
40332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40333 if (SWIG_arg_fail(1)) SWIG_fail;
40334 {
40335 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40336 if (SWIG_arg_fail(2)) SWIG_fail;
40337 }
40338 {
40339 PyThreadState* __tstate = wxPyBeginAllowThreads();
40340 (arg1)->RemoveGrowableCol(arg2);
40341
40342 wxPyEndAllowThreads(__tstate);
40343 if (PyErr_Occurred()) SWIG_fail;
40344 }
40345 Py_INCREF(Py_None); resultobj = Py_None;
40346 return resultobj;
40347 fail:
40348 return NULL;
40349 }
40350
40351
40352 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40353 PyObject *resultobj;
40354 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40355 int arg2 ;
40356 PyObject * obj0 = 0 ;
40357 PyObject * obj1 = 0 ;
40358 char *kwnames[] = {
40359 (char *) "self",(char *) "direction", NULL
40360 };
40361
40362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
40363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40364 if (SWIG_arg_fail(1)) SWIG_fail;
40365 {
40366 arg2 = (int)(SWIG_As_int(obj1));
40367 if (SWIG_arg_fail(2)) SWIG_fail;
40368 }
40369 {
40370 PyThreadState* __tstate = wxPyBeginAllowThreads();
40371 (arg1)->SetFlexibleDirection(arg2);
40372
40373 wxPyEndAllowThreads(__tstate);
40374 if (PyErr_Occurred()) SWIG_fail;
40375 }
40376 Py_INCREF(Py_None); resultobj = Py_None;
40377 return resultobj;
40378 fail:
40379 return NULL;
40380 }
40381
40382
40383 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40384 PyObject *resultobj;
40385 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40386 int result;
40387 PyObject * obj0 = 0 ;
40388 char *kwnames[] = {
40389 (char *) "self", NULL
40390 };
40391
40392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
40393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40394 if (SWIG_arg_fail(1)) SWIG_fail;
40395 {
40396 PyThreadState* __tstate = wxPyBeginAllowThreads();
40397 result = (int)(arg1)->GetFlexibleDirection();
40398
40399 wxPyEndAllowThreads(__tstate);
40400 if (PyErr_Occurred()) SWIG_fail;
40401 }
40402 {
40403 resultobj = SWIG_From_int((int)(result));
40404 }
40405 return resultobj;
40406 fail:
40407 return NULL;
40408 }
40409
40410
40411 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40412 PyObject *resultobj;
40413 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40414 wxFlexSizerGrowMode arg2 ;
40415 PyObject * obj0 = 0 ;
40416 PyObject * obj1 = 0 ;
40417 char *kwnames[] = {
40418 (char *) "self",(char *) "mode", NULL
40419 };
40420
40421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
40422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40423 if (SWIG_arg_fail(1)) SWIG_fail;
40424 {
40425 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
40426 if (SWIG_arg_fail(2)) SWIG_fail;
40427 }
40428 {
40429 PyThreadState* __tstate = wxPyBeginAllowThreads();
40430 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
40431
40432 wxPyEndAllowThreads(__tstate);
40433 if (PyErr_Occurred()) SWIG_fail;
40434 }
40435 Py_INCREF(Py_None); resultobj = Py_None;
40436 return resultobj;
40437 fail:
40438 return NULL;
40439 }
40440
40441
40442 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40443 PyObject *resultobj;
40444 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40445 wxFlexSizerGrowMode result;
40446 PyObject * obj0 = 0 ;
40447 char *kwnames[] = {
40448 (char *) "self", NULL
40449 };
40450
40451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
40452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40453 if (SWIG_arg_fail(1)) SWIG_fail;
40454 {
40455 PyThreadState* __tstate = wxPyBeginAllowThreads();
40456 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
40457
40458 wxPyEndAllowThreads(__tstate);
40459 if (PyErr_Occurred()) SWIG_fail;
40460 }
40461 resultobj = SWIG_From_int((result));
40462 return resultobj;
40463 fail:
40464 return NULL;
40465 }
40466
40467
40468 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
40469 PyObject *resultobj;
40470 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40471 wxArrayInt *result;
40472 PyObject * obj0 = 0 ;
40473 char *kwnames[] = {
40474 (char *) "self", NULL
40475 };
40476
40477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
40478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40479 if (SWIG_arg_fail(1)) SWIG_fail;
40480 {
40481 PyThreadState* __tstate = wxPyBeginAllowThreads();
40482 {
40483 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
40484 result = (wxArrayInt *) &_result_ref;
40485 }
40486
40487 wxPyEndAllowThreads(__tstate);
40488 if (PyErr_Occurred()) SWIG_fail;
40489 }
40490 {
40491 resultobj = PyList_New(0);
40492 size_t idx;
40493 for (idx = 0; idx < result->GetCount(); idx += 1) {
40494 PyObject* val = PyInt_FromLong( result->Item(idx) );
40495 PyList_Append(resultobj, val);
40496 Py_DECREF(val);
40497 }
40498 }
40499 return resultobj;
40500 fail:
40501 return NULL;
40502 }
40503
40504
40505 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
40506 PyObject *resultobj;
40507 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40508 wxArrayInt *result;
40509 PyObject * obj0 = 0 ;
40510 char *kwnames[] = {
40511 (char *) "self", NULL
40512 };
40513
40514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
40515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40516 if (SWIG_arg_fail(1)) SWIG_fail;
40517 {
40518 PyThreadState* __tstate = wxPyBeginAllowThreads();
40519 {
40520 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
40521 result = (wxArrayInt *) &_result_ref;
40522 }
40523
40524 wxPyEndAllowThreads(__tstate);
40525 if (PyErr_Occurred()) SWIG_fail;
40526 }
40527 {
40528 resultobj = PyList_New(0);
40529 size_t idx;
40530 for (idx = 0; idx < result->GetCount(); idx += 1) {
40531 PyObject* val = PyInt_FromLong( result->Item(idx) );
40532 PyList_Append(resultobj, val);
40533 Py_DECREF(val);
40534 }
40535 }
40536 return resultobj;
40537 fail:
40538 return NULL;
40539 }
40540
40541
40542 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
40543 PyObject *obj;
40544 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40545 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
40546 Py_INCREF(obj);
40547 return Py_BuildValue((char *)"");
40548 }
40549 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40550 PyObject *resultobj;
40551 wxStdDialogButtonSizer *result;
40552 char *kwnames[] = {
40553 NULL
40554 };
40555
40556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
40557 {
40558 PyThreadState* __tstate = wxPyBeginAllowThreads();
40559 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
40560
40561 wxPyEndAllowThreads(__tstate);
40562 if (PyErr_Occurred()) SWIG_fail;
40563 }
40564 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
40565 return resultobj;
40566 fail:
40567 return NULL;
40568 }
40569
40570
40571 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
40572 PyObject *resultobj;
40573 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40574 wxButton *arg2 = (wxButton *) 0 ;
40575 PyObject * obj0 = 0 ;
40576 PyObject * obj1 = 0 ;
40577 char *kwnames[] = {
40578 (char *) "self",(char *) "button", NULL
40579 };
40580
40581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
40582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40583 if (SWIG_arg_fail(1)) SWIG_fail;
40584 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40585 if (SWIG_arg_fail(2)) SWIG_fail;
40586 {
40587 PyThreadState* __tstate = wxPyBeginAllowThreads();
40588 (arg1)->AddButton(arg2);
40589
40590 wxPyEndAllowThreads(__tstate);
40591 if (PyErr_Occurred()) SWIG_fail;
40592 }
40593 Py_INCREF(Py_None); resultobj = Py_None;
40594 return resultobj;
40595 fail:
40596 return NULL;
40597 }
40598
40599
40600 static PyObject *_wrap_StdDialogButtonSizer_Finalise(PyObject *, PyObject *args, PyObject *kwargs) {
40601 PyObject *resultobj;
40602 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40603 PyObject * obj0 = 0 ;
40604 char *kwnames[] = {
40605 (char *) "self", NULL
40606 };
40607
40608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Finalise",kwnames,&obj0)) goto fail;
40609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40610 if (SWIG_arg_fail(1)) SWIG_fail;
40611 {
40612 PyThreadState* __tstate = wxPyBeginAllowThreads();
40613 (arg1)->Finalise();
40614
40615 wxPyEndAllowThreads(__tstate);
40616 if (PyErr_Occurred()) SWIG_fail;
40617 }
40618 Py_INCREF(Py_None); resultobj = Py_None;
40619 return resultobj;
40620 fail:
40621 return NULL;
40622 }
40623
40624
40625 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40626 PyObject *resultobj;
40627 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40628 wxButton *result;
40629 PyObject * obj0 = 0 ;
40630 char *kwnames[] = {
40631 (char *) "self", NULL
40632 };
40633
40634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
40635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40636 if (SWIG_arg_fail(1)) SWIG_fail;
40637 {
40638 PyThreadState* __tstate = wxPyBeginAllowThreads();
40639 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
40640
40641 wxPyEndAllowThreads(__tstate);
40642 if (PyErr_Occurred()) SWIG_fail;
40643 }
40644 {
40645 resultobj = wxPyMake_wxObject(result, 0);
40646 }
40647 return resultobj;
40648 fail:
40649 return NULL;
40650 }
40651
40652
40653 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
40654 PyObject *resultobj;
40655 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40656 wxButton *result;
40657 PyObject * obj0 = 0 ;
40658 char *kwnames[] = {
40659 (char *) "self", NULL
40660 };
40661
40662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
40663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40664 if (SWIG_arg_fail(1)) SWIG_fail;
40665 {
40666 PyThreadState* __tstate = wxPyBeginAllowThreads();
40667 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
40668
40669 wxPyEndAllowThreads(__tstate);
40670 if (PyErr_Occurred()) SWIG_fail;
40671 }
40672 {
40673 resultobj = wxPyMake_wxObject(result, 0);
40674 }
40675 return resultobj;
40676 fail:
40677 return NULL;
40678 }
40679
40680
40681 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40682 PyObject *resultobj;
40683 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40684 wxButton *result;
40685 PyObject * obj0 = 0 ;
40686 char *kwnames[] = {
40687 (char *) "self", NULL
40688 };
40689
40690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
40691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40692 if (SWIG_arg_fail(1)) SWIG_fail;
40693 {
40694 PyThreadState* __tstate = wxPyBeginAllowThreads();
40695 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
40696
40697 wxPyEndAllowThreads(__tstate);
40698 if (PyErr_Occurred()) SWIG_fail;
40699 }
40700 {
40701 resultobj = wxPyMake_wxObject(result, 0);
40702 }
40703 return resultobj;
40704 fail:
40705 return NULL;
40706 }
40707
40708
40709 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
40710 PyObject *resultobj;
40711 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40712 wxButton *result;
40713 PyObject * obj0 = 0 ;
40714 char *kwnames[] = {
40715 (char *) "self", NULL
40716 };
40717
40718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
40719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40720 if (SWIG_arg_fail(1)) SWIG_fail;
40721 {
40722 PyThreadState* __tstate = wxPyBeginAllowThreads();
40723 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
40724
40725 wxPyEndAllowThreads(__tstate);
40726 if (PyErr_Occurred()) SWIG_fail;
40727 }
40728 {
40729 resultobj = wxPyMake_wxObject(result, 0);
40730 }
40731 return resultobj;
40732 fail:
40733 return NULL;
40734 }
40735
40736
40737 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
40738 PyObject *resultobj;
40739 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40740 wxButton *result;
40741 PyObject * obj0 = 0 ;
40742 char *kwnames[] = {
40743 (char *) "self", NULL
40744 };
40745
40746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
40747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40748 if (SWIG_arg_fail(1)) SWIG_fail;
40749 {
40750 PyThreadState* __tstate = wxPyBeginAllowThreads();
40751 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
40752
40753 wxPyEndAllowThreads(__tstate);
40754 if (PyErr_Occurred()) SWIG_fail;
40755 }
40756 {
40757 resultobj = wxPyMake_wxObject(result, 0);
40758 }
40759 return resultobj;
40760 fail:
40761 return NULL;
40762 }
40763
40764
40765 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
40766 PyObject *obj;
40767 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40768 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
40769 Py_INCREF(obj);
40770 return Py_BuildValue((char *)"");
40771 }
40772 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40773 PyObject *resultobj;
40774 int arg1 = (int) 0 ;
40775 int arg2 = (int) 0 ;
40776 wxGBPosition *result;
40777 PyObject * obj0 = 0 ;
40778 PyObject * obj1 = 0 ;
40779 char *kwnames[] = {
40780 (char *) "row",(char *) "col", NULL
40781 };
40782
40783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
40784 if (obj0) {
40785 {
40786 arg1 = (int)(SWIG_As_int(obj0));
40787 if (SWIG_arg_fail(1)) SWIG_fail;
40788 }
40789 }
40790 if (obj1) {
40791 {
40792 arg2 = (int)(SWIG_As_int(obj1));
40793 if (SWIG_arg_fail(2)) SWIG_fail;
40794 }
40795 }
40796 {
40797 PyThreadState* __tstate = wxPyBeginAllowThreads();
40798 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
40799
40800 wxPyEndAllowThreads(__tstate);
40801 if (PyErr_Occurred()) SWIG_fail;
40802 }
40803 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
40804 return resultobj;
40805 fail:
40806 return NULL;
40807 }
40808
40809
40810 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
40811 PyObject *resultobj;
40812 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40813 int result;
40814 PyObject * obj0 = 0 ;
40815 char *kwnames[] = {
40816 (char *) "self", NULL
40817 };
40818
40819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
40820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40821 if (SWIG_arg_fail(1)) SWIG_fail;
40822 {
40823 PyThreadState* __tstate = wxPyBeginAllowThreads();
40824 result = (int)((wxGBPosition const *)arg1)->GetRow();
40825
40826 wxPyEndAllowThreads(__tstate);
40827 if (PyErr_Occurred()) SWIG_fail;
40828 }
40829 {
40830 resultobj = SWIG_From_int((int)(result));
40831 }
40832 return resultobj;
40833 fail:
40834 return NULL;
40835 }
40836
40837
40838 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
40839 PyObject *resultobj;
40840 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40841 int result;
40842 PyObject * obj0 = 0 ;
40843 char *kwnames[] = {
40844 (char *) "self", NULL
40845 };
40846
40847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
40848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40849 if (SWIG_arg_fail(1)) SWIG_fail;
40850 {
40851 PyThreadState* __tstate = wxPyBeginAllowThreads();
40852 result = (int)((wxGBPosition const *)arg1)->GetCol();
40853
40854 wxPyEndAllowThreads(__tstate);
40855 if (PyErr_Occurred()) SWIG_fail;
40856 }
40857 {
40858 resultobj = SWIG_From_int((int)(result));
40859 }
40860 return resultobj;
40861 fail:
40862 return NULL;
40863 }
40864
40865
40866 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
40867 PyObject *resultobj;
40868 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40869 int arg2 ;
40870 PyObject * obj0 = 0 ;
40871 PyObject * obj1 = 0 ;
40872 char *kwnames[] = {
40873 (char *) "self",(char *) "row", NULL
40874 };
40875
40876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
40877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40878 if (SWIG_arg_fail(1)) SWIG_fail;
40879 {
40880 arg2 = (int)(SWIG_As_int(obj1));
40881 if (SWIG_arg_fail(2)) SWIG_fail;
40882 }
40883 {
40884 PyThreadState* __tstate = wxPyBeginAllowThreads();
40885 (arg1)->SetRow(arg2);
40886
40887 wxPyEndAllowThreads(__tstate);
40888 if (PyErr_Occurred()) SWIG_fail;
40889 }
40890 Py_INCREF(Py_None); resultobj = Py_None;
40891 return resultobj;
40892 fail:
40893 return NULL;
40894 }
40895
40896
40897 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
40898 PyObject *resultobj;
40899 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40900 int arg2 ;
40901 PyObject * obj0 = 0 ;
40902 PyObject * obj1 = 0 ;
40903 char *kwnames[] = {
40904 (char *) "self",(char *) "col", NULL
40905 };
40906
40907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
40908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40909 if (SWIG_arg_fail(1)) SWIG_fail;
40910 {
40911 arg2 = (int)(SWIG_As_int(obj1));
40912 if (SWIG_arg_fail(2)) SWIG_fail;
40913 }
40914 {
40915 PyThreadState* __tstate = wxPyBeginAllowThreads();
40916 (arg1)->SetCol(arg2);
40917
40918 wxPyEndAllowThreads(__tstate);
40919 if (PyErr_Occurred()) SWIG_fail;
40920 }
40921 Py_INCREF(Py_None); resultobj = Py_None;
40922 return resultobj;
40923 fail:
40924 return NULL;
40925 }
40926
40927
40928 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
40929 PyObject *resultobj;
40930 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40931 wxGBPosition *arg2 = 0 ;
40932 bool result;
40933 wxGBPosition temp2 ;
40934 PyObject * obj0 = 0 ;
40935 PyObject * obj1 = 0 ;
40936 char *kwnames[] = {
40937 (char *) "self",(char *) "other", NULL
40938 };
40939
40940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
40941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40942 if (SWIG_arg_fail(1)) SWIG_fail;
40943 {
40944 arg2 = &temp2;
40945 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40946 }
40947 {
40948 PyThreadState* __tstate = wxPyBeginAllowThreads();
40949 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
40950
40951 wxPyEndAllowThreads(__tstate);
40952 if (PyErr_Occurred()) SWIG_fail;
40953 }
40954 {
40955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40956 }
40957 return resultobj;
40958 fail:
40959 return NULL;
40960 }
40961
40962
40963 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
40964 PyObject *resultobj;
40965 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40966 wxGBPosition *arg2 = 0 ;
40967 bool result;
40968 wxGBPosition temp2 ;
40969 PyObject * obj0 = 0 ;
40970 PyObject * obj1 = 0 ;
40971 char *kwnames[] = {
40972 (char *) "self",(char *) "other", NULL
40973 };
40974
40975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
40976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40977 if (SWIG_arg_fail(1)) SWIG_fail;
40978 {
40979 arg2 = &temp2;
40980 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40981 }
40982 {
40983 PyThreadState* __tstate = wxPyBeginAllowThreads();
40984 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
40985
40986 wxPyEndAllowThreads(__tstate);
40987 if (PyErr_Occurred()) SWIG_fail;
40988 }
40989 {
40990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40991 }
40992 return resultobj;
40993 fail:
40994 return NULL;
40995 }
40996
40997
40998 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
40999 PyObject *resultobj;
41000 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41001 int arg2 = (int) 0 ;
41002 int arg3 = (int) 0 ;
41003 PyObject * obj0 = 0 ;
41004 PyObject * obj1 = 0 ;
41005 PyObject * obj2 = 0 ;
41006 char *kwnames[] = {
41007 (char *) "self",(char *) "row",(char *) "col", NULL
41008 };
41009
41010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41012 if (SWIG_arg_fail(1)) SWIG_fail;
41013 if (obj1) {
41014 {
41015 arg2 = (int)(SWIG_As_int(obj1));
41016 if (SWIG_arg_fail(2)) SWIG_fail;
41017 }
41018 }
41019 if (obj2) {
41020 {
41021 arg3 = (int)(SWIG_As_int(obj2));
41022 if (SWIG_arg_fail(3)) SWIG_fail;
41023 }
41024 }
41025 {
41026 PyThreadState* __tstate = wxPyBeginAllowThreads();
41027 wxGBPosition_Set(arg1,arg2,arg3);
41028
41029 wxPyEndAllowThreads(__tstate);
41030 if (PyErr_Occurred()) SWIG_fail;
41031 }
41032 Py_INCREF(Py_None); resultobj = Py_None;
41033 return resultobj;
41034 fail:
41035 return NULL;
41036 }
41037
41038
41039 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41040 PyObject *resultobj;
41041 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41042 PyObject *result;
41043 PyObject * obj0 = 0 ;
41044 char *kwnames[] = {
41045 (char *) "self", NULL
41046 };
41047
41048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
41049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41050 if (SWIG_arg_fail(1)) SWIG_fail;
41051 {
41052 PyThreadState* __tstate = wxPyBeginAllowThreads();
41053 result = (PyObject *)wxGBPosition_Get(arg1);
41054
41055 wxPyEndAllowThreads(__tstate);
41056 if (PyErr_Occurred()) SWIG_fail;
41057 }
41058 resultobj = result;
41059 return resultobj;
41060 fail:
41061 return NULL;
41062 }
41063
41064
41065 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
41066 PyObject *obj;
41067 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41068 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
41069 Py_INCREF(obj);
41070 return Py_BuildValue((char *)"");
41071 }
41072 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41073 PyObject *resultobj;
41074 int arg1 = (int) 1 ;
41075 int arg2 = (int) 1 ;
41076 wxGBSpan *result;
41077 PyObject * obj0 = 0 ;
41078 PyObject * obj1 = 0 ;
41079 char *kwnames[] = {
41080 (char *) "rowspan",(char *) "colspan", NULL
41081 };
41082
41083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
41084 if (obj0) {
41085 {
41086 arg1 = (int)(SWIG_As_int(obj0));
41087 if (SWIG_arg_fail(1)) SWIG_fail;
41088 }
41089 }
41090 if (obj1) {
41091 {
41092 arg2 = (int)(SWIG_As_int(obj1));
41093 if (SWIG_arg_fail(2)) SWIG_fail;
41094 }
41095 }
41096 {
41097 PyThreadState* __tstate = wxPyBeginAllowThreads();
41098 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
41099
41100 wxPyEndAllowThreads(__tstate);
41101 if (PyErr_Occurred()) SWIG_fail;
41102 }
41103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
41104 return resultobj;
41105 fail:
41106 return NULL;
41107 }
41108
41109
41110 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41111 PyObject *resultobj;
41112 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41113 int result;
41114 PyObject * obj0 = 0 ;
41115 char *kwnames[] = {
41116 (char *) "self", NULL
41117 };
41118
41119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
41120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41121 if (SWIG_arg_fail(1)) SWIG_fail;
41122 {
41123 PyThreadState* __tstate = wxPyBeginAllowThreads();
41124 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
41125
41126 wxPyEndAllowThreads(__tstate);
41127 if (PyErr_Occurred()) SWIG_fail;
41128 }
41129 {
41130 resultobj = SWIG_From_int((int)(result));
41131 }
41132 return resultobj;
41133 fail:
41134 return NULL;
41135 }
41136
41137
41138 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41139 PyObject *resultobj;
41140 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41141 int result;
41142 PyObject * obj0 = 0 ;
41143 char *kwnames[] = {
41144 (char *) "self", NULL
41145 };
41146
41147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
41148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41149 if (SWIG_arg_fail(1)) SWIG_fail;
41150 {
41151 PyThreadState* __tstate = wxPyBeginAllowThreads();
41152 result = (int)((wxGBSpan const *)arg1)->GetColspan();
41153
41154 wxPyEndAllowThreads(__tstate);
41155 if (PyErr_Occurred()) SWIG_fail;
41156 }
41157 {
41158 resultobj = SWIG_From_int((int)(result));
41159 }
41160 return resultobj;
41161 fail:
41162 return NULL;
41163 }
41164
41165
41166 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41167 PyObject *resultobj;
41168 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41169 int arg2 ;
41170 PyObject * obj0 = 0 ;
41171 PyObject * obj1 = 0 ;
41172 char *kwnames[] = {
41173 (char *) "self",(char *) "rowspan", NULL
41174 };
41175
41176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
41177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41178 if (SWIG_arg_fail(1)) SWIG_fail;
41179 {
41180 arg2 = (int)(SWIG_As_int(obj1));
41181 if (SWIG_arg_fail(2)) SWIG_fail;
41182 }
41183 {
41184 PyThreadState* __tstate = wxPyBeginAllowThreads();
41185 (arg1)->SetRowspan(arg2);
41186
41187 wxPyEndAllowThreads(__tstate);
41188 if (PyErr_Occurred()) SWIG_fail;
41189 }
41190 Py_INCREF(Py_None); resultobj = Py_None;
41191 return resultobj;
41192 fail:
41193 return NULL;
41194 }
41195
41196
41197 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41198 PyObject *resultobj;
41199 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41200 int arg2 ;
41201 PyObject * obj0 = 0 ;
41202 PyObject * obj1 = 0 ;
41203 char *kwnames[] = {
41204 (char *) "self",(char *) "colspan", NULL
41205 };
41206
41207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
41208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41209 if (SWIG_arg_fail(1)) SWIG_fail;
41210 {
41211 arg2 = (int)(SWIG_As_int(obj1));
41212 if (SWIG_arg_fail(2)) SWIG_fail;
41213 }
41214 {
41215 PyThreadState* __tstate = wxPyBeginAllowThreads();
41216 (arg1)->SetColspan(arg2);
41217
41218 wxPyEndAllowThreads(__tstate);
41219 if (PyErr_Occurred()) SWIG_fail;
41220 }
41221 Py_INCREF(Py_None); resultobj = Py_None;
41222 return resultobj;
41223 fail:
41224 return NULL;
41225 }
41226
41227
41228 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41229 PyObject *resultobj;
41230 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41231 wxGBSpan *arg2 = 0 ;
41232 bool result;
41233 wxGBSpan temp2 ;
41234 PyObject * obj0 = 0 ;
41235 PyObject * obj1 = 0 ;
41236 char *kwnames[] = {
41237 (char *) "self",(char *) "other", NULL
41238 };
41239
41240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
41241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41242 if (SWIG_arg_fail(1)) SWIG_fail;
41243 {
41244 arg2 = &temp2;
41245 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41246 }
41247 {
41248 PyThreadState* __tstate = wxPyBeginAllowThreads();
41249 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
41250
41251 wxPyEndAllowThreads(__tstate);
41252 if (PyErr_Occurred()) SWIG_fail;
41253 }
41254 {
41255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41256 }
41257 return resultobj;
41258 fail:
41259 return NULL;
41260 }
41261
41262
41263 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41264 PyObject *resultobj;
41265 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41266 wxGBSpan *arg2 = 0 ;
41267 bool result;
41268 wxGBSpan temp2 ;
41269 PyObject * obj0 = 0 ;
41270 PyObject * obj1 = 0 ;
41271 char *kwnames[] = {
41272 (char *) "self",(char *) "other", NULL
41273 };
41274
41275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
41276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41277 if (SWIG_arg_fail(1)) SWIG_fail;
41278 {
41279 arg2 = &temp2;
41280 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41281 }
41282 {
41283 PyThreadState* __tstate = wxPyBeginAllowThreads();
41284 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
41285
41286 wxPyEndAllowThreads(__tstate);
41287 if (PyErr_Occurred()) SWIG_fail;
41288 }
41289 {
41290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41291 }
41292 return resultobj;
41293 fail:
41294 return NULL;
41295 }
41296
41297
41298 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41299 PyObject *resultobj;
41300 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41301 int arg2 = (int) 1 ;
41302 int arg3 = (int) 1 ;
41303 PyObject * obj0 = 0 ;
41304 PyObject * obj1 = 0 ;
41305 PyObject * obj2 = 0 ;
41306 char *kwnames[] = {
41307 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
41308 };
41309
41310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41312 if (SWIG_arg_fail(1)) SWIG_fail;
41313 if (obj1) {
41314 {
41315 arg2 = (int)(SWIG_As_int(obj1));
41316 if (SWIG_arg_fail(2)) SWIG_fail;
41317 }
41318 }
41319 if (obj2) {
41320 {
41321 arg3 = (int)(SWIG_As_int(obj2));
41322 if (SWIG_arg_fail(3)) SWIG_fail;
41323 }
41324 }
41325 {
41326 PyThreadState* __tstate = wxPyBeginAllowThreads();
41327 wxGBSpan_Set(arg1,arg2,arg3);
41328
41329 wxPyEndAllowThreads(__tstate);
41330 if (PyErr_Occurred()) SWIG_fail;
41331 }
41332 Py_INCREF(Py_None); resultobj = Py_None;
41333 return resultobj;
41334 fail:
41335 return NULL;
41336 }
41337
41338
41339 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41340 PyObject *resultobj;
41341 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41342 PyObject *result;
41343 PyObject * obj0 = 0 ;
41344 char *kwnames[] = {
41345 (char *) "self", NULL
41346 };
41347
41348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
41349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41350 if (SWIG_arg_fail(1)) SWIG_fail;
41351 {
41352 PyThreadState* __tstate = wxPyBeginAllowThreads();
41353 result = (PyObject *)wxGBSpan_Get(arg1);
41354
41355 wxPyEndAllowThreads(__tstate);
41356 if (PyErr_Occurred()) SWIG_fail;
41357 }
41358 resultobj = result;
41359 return resultobj;
41360 fail:
41361 return NULL;
41362 }
41363
41364
41365 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
41366 PyObject *obj;
41367 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41368 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
41369 Py_INCREF(obj);
41370 return Py_BuildValue((char *)"");
41371 }
41372 static int _wrap_DefaultSpan_set(PyObject *) {
41373 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
41374 return 1;
41375 }
41376
41377
41378 static PyObject *_wrap_DefaultSpan_get(void) {
41379 PyObject *pyobj;
41380
41381 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
41382 return pyobj;
41383 }
41384
41385
41386 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
41387 PyObject *resultobj;
41388 wxGBSizerItem *result;
41389 char *kwnames[] = {
41390 NULL
41391 };
41392
41393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
41394 {
41395 PyThreadState* __tstate = wxPyBeginAllowThreads();
41396 result = (wxGBSizerItem *)new wxGBSizerItem();
41397
41398 wxPyEndAllowThreads(__tstate);
41399 if (PyErr_Occurred()) SWIG_fail;
41400 }
41401 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41402 return resultobj;
41403 fail:
41404 return NULL;
41405 }
41406
41407
41408 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
41409 PyObject *resultobj;
41410 wxWindow *arg1 = (wxWindow *) 0 ;
41411 wxGBPosition *arg2 = 0 ;
41412 wxGBSpan *arg3 = 0 ;
41413 int arg4 ;
41414 int arg5 ;
41415 PyObject *arg6 = (PyObject *) NULL ;
41416 wxGBSizerItem *result;
41417 wxGBPosition temp2 ;
41418 wxGBSpan temp3 ;
41419 PyObject * obj0 = 0 ;
41420 PyObject * obj1 = 0 ;
41421 PyObject * obj2 = 0 ;
41422 PyObject * obj3 = 0 ;
41423 PyObject * obj4 = 0 ;
41424 PyObject * obj5 = 0 ;
41425 char *kwnames[] = {
41426 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41427 };
41428
41429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41431 if (SWIG_arg_fail(1)) SWIG_fail;
41432 {
41433 arg2 = &temp2;
41434 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41435 }
41436 {
41437 arg3 = &temp3;
41438 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41439 }
41440 {
41441 arg4 = (int)(SWIG_As_int(obj3));
41442 if (SWIG_arg_fail(4)) SWIG_fail;
41443 }
41444 {
41445 arg5 = (int)(SWIG_As_int(obj4));
41446 if (SWIG_arg_fail(5)) SWIG_fail;
41447 }
41448 if (obj5) {
41449 arg6 = obj5;
41450 }
41451 {
41452 PyThreadState* __tstate = wxPyBeginAllowThreads();
41453 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41454
41455 wxPyEndAllowThreads(__tstate);
41456 if (PyErr_Occurred()) SWIG_fail;
41457 }
41458 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41459 return resultobj;
41460 fail:
41461 return NULL;
41462 }
41463
41464
41465 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41466 PyObject *resultobj;
41467 wxSizer *arg1 = (wxSizer *) 0 ;
41468 wxGBPosition *arg2 = 0 ;
41469 wxGBSpan *arg3 = 0 ;
41470 int arg4 ;
41471 int arg5 ;
41472 PyObject *arg6 = (PyObject *) NULL ;
41473 wxGBSizerItem *result;
41474 wxGBPosition temp2 ;
41475 wxGBSpan temp3 ;
41476 PyObject * obj0 = 0 ;
41477 PyObject * obj1 = 0 ;
41478 PyObject * obj2 = 0 ;
41479 PyObject * obj3 = 0 ;
41480 PyObject * obj4 = 0 ;
41481 PyObject * obj5 = 0 ;
41482 char *kwnames[] = {
41483 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41484 };
41485
41486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41488 if (SWIG_arg_fail(1)) SWIG_fail;
41489 {
41490 arg2 = &temp2;
41491 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41492 }
41493 {
41494 arg3 = &temp3;
41495 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41496 }
41497 {
41498 arg4 = (int)(SWIG_As_int(obj3));
41499 if (SWIG_arg_fail(4)) SWIG_fail;
41500 }
41501 {
41502 arg5 = (int)(SWIG_As_int(obj4));
41503 if (SWIG_arg_fail(5)) SWIG_fail;
41504 }
41505 if (obj5) {
41506 arg6 = obj5;
41507 }
41508 {
41509 PyThreadState* __tstate = wxPyBeginAllowThreads();
41510 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41511
41512 wxPyEndAllowThreads(__tstate);
41513 if (PyErr_Occurred()) SWIG_fail;
41514 }
41515 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41516 return resultobj;
41517 fail:
41518 return NULL;
41519 }
41520
41521
41522 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
41523 PyObject *resultobj;
41524 int arg1 ;
41525 int arg2 ;
41526 wxGBPosition *arg3 = 0 ;
41527 wxGBSpan *arg4 = 0 ;
41528 int arg5 ;
41529 int arg6 ;
41530 PyObject *arg7 = (PyObject *) NULL ;
41531 wxGBSizerItem *result;
41532 wxGBPosition temp3 ;
41533 wxGBSpan temp4 ;
41534 PyObject * obj0 = 0 ;
41535 PyObject * obj1 = 0 ;
41536 PyObject * obj2 = 0 ;
41537 PyObject * obj3 = 0 ;
41538 PyObject * obj4 = 0 ;
41539 PyObject * obj5 = 0 ;
41540 PyObject * obj6 = 0 ;
41541 char *kwnames[] = {
41542 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41543 };
41544
41545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41546 {
41547 arg1 = (int)(SWIG_As_int(obj0));
41548 if (SWIG_arg_fail(1)) SWIG_fail;
41549 }
41550 {
41551 arg2 = (int)(SWIG_As_int(obj1));
41552 if (SWIG_arg_fail(2)) SWIG_fail;
41553 }
41554 {
41555 arg3 = &temp3;
41556 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41557 }
41558 {
41559 arg4 = &temp4;
41560 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
41561 }
41562 {
41563 arg5 = (int)(SWIG_As_int(obj4));
41564 if (SWIG_arg_fail(5)) SWIG_fail;
41565 }
41566 {
41567 arg6 = (int)(SWIG_As_int(obj5));
41568 if (SWIG_arg_fail(6)) SWIG_fail;
41569 }
41570 if (obj6) {
41571 arg7 = obj6;
41572 }
41573 {
41574 PyThreadState* __tstate = wxPyBeginAllowThreads();
41575 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
41576
41577 wxPyEndAllowThreads(__tstate);
41578 if (PyErr_Occurred()) SWIG_fail;
41579 }
41580 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41581 return resultobj;
41582 fail:
41583 return NULL;
41584 }
41585
41586
41587 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
41588 PyObject *resultobj;
41589 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41590 wxGBPosition result;
41591 PyObject * obj0 = 0 ;
41592 char *kwnames[] = {
41593 (char *) "self", NULL
41594 };
41595
41596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
41597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41598 if (SWIG_arg_fail(1)) SWIG_fail;
41599 {
41600 PyThreadState* __tstate = wxPyBeginAllowThreads();
41601 result = ((wxGBSizerItem const *)arg1)->GetPos();
41602
41603 wxPyEndAllowThreads(__tstate);
41604 if (PyErr_Occurred()) SWIG_fail;
41605 }
41606 {
41607 wxGBPosition * resultptr;
41608 resultptr = new wxGBPosition((wxGBPosition &)(result));
41609 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41610 }
41611 return resultobj;
41612 fail:
41613 return NULL;
41614 }
41615
41616
41617 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41618 PyObject *resultobj;
41619 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41620 wxGBSpan result;
41621 PyObject * obj0 = 0 ;
41622 char *kwnames[] = {
41623 (char *) "self", NULL
41624 };
41625
41626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
41627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41628 if (SWIG_arg_fail(1)) SWIG_fail;
41629 {
41630 PyThreadState* __tstate = wxPyBeginAllowThreads();
41631 result = ((wxGBSizerItem const *)arg1)->GetSpan();
41632
41633 wxPyEndAllowThreads(__tstate);
41634 if (PyErr_Occurred()) SWIG_fail;
41635 }
41636 {
41637 wxGBSpan * resultptr;
41638 resultptr = new wxGBSpan((wxGBSpan &)(result));
41639 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
41640 }
41641 return resultobj;
41642 fail:
41643 return NULL;
41644 }
41645
41646
41647 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
41648 PyObject *resultobj;
41649 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41650 wxGBPosition *arg2 = 0 ;
41651 bool result;
41652 wxGBPosition temp2 ;
41653 PyObject * obj0 = 0 ;
41654 PyObject * obj1 = 0 ;
41655 char *kwnames[] = {
41656 (char *) "self",(char *) "pos", NULL
41657 };
41658
41659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
41660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41661 if (SWIG_arg_fail(1)) SWIG_fail;
41662 {
41663 arg2 = &temp2;
41664 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41665 }
41666 {
41667 PyThreadState* __tstate = wxPyBeginAllowThreads();
41668 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
41669
41670 wxPyEndAllowThreads(__tstate);
41671 if (PyErr_Occurred()) SWIG_fail;
41672 }
41673 {
41674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41675 }
41676 return resultobj;
41677 fail:
41678 return NULL;
41679 }
41680
41681
41682 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41683 PyObject *resultobj;
41684 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41685 wxGBSpan *arg2 = 0 ;
41686 bool result;
41687 wxGBSpan temp2 ;
41688 PyObject * obj0 = 0 ;
41689 PyObject * obj1 = 0 ;
41690 char *kwnames[] = {
41691 (char *) "self",(char *) "span", NULL
41692 };
41693
41694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
41695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41696 if (SWIG_arg_fail(1)) SWIG_fail;
41697 {
41698 arg2 = &temp2;
41699 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41700 }
41701 {
41702 PyThreadState* __tstate = wxPyBeginAllowThreads();
41703 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
41704
41705 wxPyEndAllowThreads(__tstate);
41706 if (PyErr_Occurred()) SWIG_fail;
41707 }
41708 {
41709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41710 }
41711 return resultobj;
41712 fail:
41713 return NULL;
41714 }
41715
41716
41717 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
41718 PyObject *resultobj;
41719 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41720 wxGBSizerItem *arg2 = 0 ;
41721 bool result;
41722 PyObject * obj0 = 0 ;
41723 PyObject * obj1 = 0 ;
41724 char *kwnames[] = {
41725 (char *) "self",(char *) "other", NULL
41726 };
41727
41728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
41729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41730 if (SWIG_arg_fail(1)) SWIG_fail;
41731 {
41732 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41733 if (SWIG_arg_fail(2)) SWIG_fail;
41734 if (arg2 == NULL) {
41735 SWIG_null_ref("wxGBSizerItem");
41736 }
41737 if (SWIG_arg_fail(2)) SWIG_fail;
41738 }
41739 {
41740 PyThreadState* __tstate = wxPyBeginAllowThreads();
41741 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
41742
41743 wxPyEndAllowThreads(__tstate);
41744 if (PyErr_Occurred()) SWIG_fail;
41745 }
41746 {
41747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41748 }
41749 return resultobj;
41750 fail:
41751 return NULL;
41752 }
41753
41754
41755 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
41756 PyObject *resultobj;
41757 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41758 wxGBPosition *arg2 = 0 ;
41759 wxGBSpan *arg3 = 0 ;
41760 bool result;
41761 wxGBPosition temp2 ;
41762 wxGBSpan temp3 ;
41763 PyObject * obj0 = 0 ;
41764 PyObject * obj1 = 0 ;
41765 PyObject * obj2 = 0 ;
41766 char *kwnames[] = {
41767 (char *) "self",(char *) "pos",(char *) "span", NULL
41768 };
41769
41770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
41771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41772 if (SWIG_arg_fail(1)) SWIG_fail;
41773 {
41774 arg2 = &temp2;
41775 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41776 }
41777 {
41778 arg3 = &temp3;
41779 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41780 }
41781 {
41782 PyThreadState* __tstate = wxPyBeginAllowThreads();
41783 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
41784
41785 wxPyEndAllowThreads(__tstate);
41786 if (PyErr_Occurred()) SWIG_fail;
41787 }
41788 {
41789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41790 }
41791 return resultobj;
41792 fail:
41793 return NULL;
41794 }
41795
41796
41797 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
41798 PyObject *resultobj;
41799 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41800 wxGBPosition result;
41801 PyObject * obj0 = 0 ;
41802 char *kwnames[] = {
41803 (char *) "self", NULL
41804 };
41805
41806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
41807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41808 if (SWIG_arg_fail(1)) SWIG_fail;
41809 {
41810 PyThreadState* __tstate = wxPyBeginAllowThreads();
41811 result = wxGBSizerItem_GetEndPos(arg1);
41812
41813 wxPyEndAllowThreads(__tstate);
41814 if (PyErr_Occurred()) SWIG_fail;
41815 }
41816 {
41817 wxGBPosition * resultptr;
41818 resultptr = new wxGBPosition((wxGBPosition &)(result));
41819 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41820 }
41821 return resultobj;
41822 fail:
41823 return NULL;
41824 }
41825
41826
41827 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41828 PyObject *resultobj;
41829 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41830 wxGridBagSizer *result;
41831 PyObject * obj0 = 0 ;
41832 char *kwnames[] = {
41833 (char *) "self", NULL
41834 };
41835
41836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
41837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41838 if (SWIG_arg_fail(1)) SWIG_fail;
41839 {
41840 PyThreadState* __tstate = wxPyBeginAllowThreads();
41841 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
41842
41843 wxPyEndAllowThreads(__tstate);
41844 if (PyErr_Occurred()) SWIG_fail;
41845 }
41846 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
41847 return resultobj;
41848 fail:
41849 return NULL;
41850 }
41851
41852
41853 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41854 PyObject *resultobj;
41855 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41856 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
41857 PyObject * obj0 = 0 ;
41858 PyObject * obj1 = 0 ;
41859 char *kwnames[] = {
41860 (char *) "self",(char *) "sizer", NULL
41861 };
41862
41863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
41864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41865 if (SWIG_arg_fail(1)) SWIG_fail;
41866 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41867 if (SWIG_arg_fail(2)) SWIG_fail;
41868 {
41869 PyThreadState* __tstate = wxPyBeginAllowThreads();
41870 (arg1)->SetGBSizer(arg2);
41871
41872 wxPyEndAllowThreads(__tstate);
41873 if (PyErr_Occurred()) SWIG_fail;
41874 }
41875 Py_INCREF(Py_None); resultobj = Py_None;
41876 return resultobj;
41877 fail:
41878 return NULL;
41879 }
41880
41881
41882 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
41883 PyObject *obj;
41884 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41885 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
41886 Py_INCREF(obj);
41887 return Py_BuildValue((char *)"");
41888 }
41889 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41890 PyObject *resultobj;
41891 int arg1 = (int) 0 ;
41892 int arg2 = (int) 0 ;
41893 wxGridBagSizer *result;
41894 PyObject * obj0 = 0 ;
41895 PyObject * obj1 = 0 ;
41896 char *kwnames[] = {
41897 (char *) "vgap",(char *) "hgap", NULL
41898 };
41899
41900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
41901 if (obj0) {
41902 {
41903 arg1 = (int)(SWIG_As_int(obj0));
41904 if (SWIG_arg_fail(1)) SWIG_fail;
41905 }
41906 }
41907 if (obj1) {
41908 {
41909 arg2 = (int)(SWIG_As_int(obj1));
41910 if (SWIG_arg_fail(2)) SWIG_fail;
41911 }
41912 }
41913 {
41914 PyThreadState* __tstate = wxPyBeginAllowThreads();
41915 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
41916
41917 wxPyEndAllowThreads(__tstate);
41918 if (PyErr_Occurred()) SWIG_fail;
41919 }
41920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
41921 return resultobj;
41922 fail:
41923 return NULL;
41924 }
41925
41926
41927 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
41928 PyObject *resultobj;
41929 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41930 PyObject *arg2 = (PyObject *) 0 ;
41931 wxGBPosition *arg3 = 0 ;
41932 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
41933 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
41934 int arg5 = (int) 0 ;
41935 int arg6 = (int) 0 ;
41936 PyObject *arg7 = (PyObject *) NULL ;
41937 wxGBSizerItem *result;
41938 wxGBPosition temp3 ;
41939 wxGBSpan temp4 ;
41940 PyObject * obj0 = 0 ;
41941 PyObject * obj1 = 0 ;
41942 PyObject * obj2 = 0 ;
41943 PyObject * obj3 = 0 ;
41944 PyObject * obj4 = 0 ;
41945 PyObject * obj5 = 0 ;
41946 PyObject * obj6 = 0 ;
41947 char *kwnames[] = {
41948 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41949 };
41950
41951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41953 if (SWIG_arg_fail(1)) SWIG_fail;
41954 arg2 = obj1;
41955 {
41956 arg3 = &temp3;
41957 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41958 }
41959 if (obj3) {
41960 {
41961 arg4 = &temp4;
41962 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
41963 }
41964 }
41965 if (obj4) {
41966 {
41967 arg5 = (int)(SWIG_As_int(obj4));
41968 if (SWIG_arg_fail(5)) SWIG_fail;
41969 }
41970 }
41971 if (obj5) {
41972 {
41973 arg6 = (int)(SWIG_As_int(obj5));
41974 if (SWIG_arg_fail(6)) SWIG_fail;
41975 }
41976 }
41977 if (obj6) {
41978 arg7 = obj6;
41979 }
41980 {
41981 PyThreadState* __tstate = wxPyBeginAllowThreads();
41982 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
41983
41984 wxPyEndAllowThreads(__tstate);
41985 if (PyErr_Occurred()) SWIG_fail;
41986 }
41987 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
41988 return resultobj;
41989 fail:
41990 return NULL;
41991 }
41992
41993
41994 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
41995 PyObject *resultobj;
41996 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41997 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
41998 wxGBSizerItem *result;
41999 PyObject * obj0 = 0 ;
42000 PyObject * obj1 = 0 ;
42001 char *kwnames[] = {
42002 (char *) "self",(char *) "item", NULL
42003 };
42004
42005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42007 if (SWIG_arg_fail(1)) SWIG_fail;
42008 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42009 if (SWIG_arg_fail(2)) SWIG_fail;
42010 {
42011 PyThreadState* __tstate = wxPyBeginAllowThreads();
42012 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42013
42014 wxPyEndAllowThreads(__tstate);
42015 if (PyErr_Occurred()) SWIG_fail;
42016 }
42017 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42018 return resultobj;
42019 fail:
42020 return NULL;
42021 }
42022
42023
42024 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42025 PyObject *resultobj;
42026 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42027 int arg2 ;
42028 int arg3 ;
42029 wxSize result;
42030 PyObject * obj0 = 0 ;
42031 PyObject * obj1 = 0 ;
42032 PyObject * obj2 = 0 ;
42033 char *kwnames[] = {
42034 (char *) "self",(char *) "row",(char *) "col", NULL
42035 };
42036
42037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
42038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42039 if (SWIG_arg_fail(1)) SWIG_fail;
42040 {
42041 arg2 = (int)(SWIG_As_int(obj1));
42042 if (SWIG_arg_fail(2)) SWIG_fail;
42043 }
42044 {
42045 arg3 = (int)(SWIG_As_int(obj2));
42046 if (SWIG_arg_fail(3)) SWIG_fail;
42047 }
42048 {
42049 PyThreadState* __tstate = wxPyBeginAllowThreads();
42050 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
42051
42052 wxPyEndAllowThreads(__tstate);
42053 if (PyErr_Occurred()) SWIG_fail;
42054 }
42055 {
42056 wxSize * resultptr;
42057 resultptr = new wxSize((wxSize &)(result));
42058 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42059 }
42060 return resultobj;
42061 fail:
42062 return NULL;
42063 }
42064
42065
42066 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42067 PyObject *resultobj;
42068 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42069 wxSize result;
42070 PyObject * obj0 = 0 ;
42071 char *kwnames[] = {
42072 (char *) "self", NULL
42073 };
42074
42075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
42076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42077 if (SWIG_arg_fail(1)) SWIG_fail;
42078 {
42079 PyThreadState* __tstate = wxPyBeginAllowThreads();
42080 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
42081
42082 wxPyEndAllowThreads(__tstate);
42083 if (PyErr_Occurred()) SWIG_fail;
42084 }
42085 {
42086 wxSize * resultptr;
42087 resultptr = new wxSize((wxSize &)(result));
42088 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42089 }
42090 return resultobj;
42091 fail:
42092 return NULL;
42093 }
42094
42095
42096 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42097 PyObject *resultobj;
42098 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42099 wxSize *arg2 = 0 ;
42100 wxSize temp2 ;
42101 PyObject * obj0 = 0 ;
42102 PyObject * obj1 = 0 ;
42103 char *kwnames[] = {
42104 (char *) "self",(char *) "sz", NULL
42105 };
42106
42107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
42108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42109 if (SWIG_arg_fail(1)) SWIG_fail;
42110 {
42111 arg2 = &temp2;
42112 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
42113 }
42114 {
42115 PyThreadState* __tstate = wxPyBeginAllowThreads();
42116 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
42117
42118 wxPyEndAllowThreads(__tstate);
42119 if (PyErr_Occurred()) SWIG_fail;
42120 }
42121 Py_INCREF(Py_None); resultobj = Py_None;
42122 return resultobj;
42123 fail:
42124 return NULL;
42125 }
42126
42127
42128 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42129 PyObject *resultobj;
42130 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42131 wxWindow *arg2 = (wxWindow *) 0 ;
42132 wxGBPosition result;
42133 PyObject * obj0 = 0 ;
42134 PyObject * obj1 = 0 ;
42135
42136 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42138 if (SWIG_arg_fail(1)) SWIG_fail;
42139 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42140 if (SWIG_arg_fail(2)) SWIG_fail;
42141 {
42142 PyThreadState* __tstate = wxPyBeginAllowThreads();
42143 result = (arg1)->GetItemPosition(arg2);
42144
42145 wxPyEndAllowThreads(__tstate);
42146 if (PyErr_Occurred()) SWIG_fail;
42147 }
42148 {
42149 wxGBPosition * resultptr;
42150 resultptr = new wxGBPosition((wxGBPosition &)(result));
42151 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42152 }
42153 return resultobj;
42154 fail:
42155 return NULL;
42156 }
42157
42158
42159 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42160 PyObject *resultobj;
42161 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42162 wxSizer *arg2 = (wxSizer *) 0 ;
42163 wxGBPosition result;
42164 PyObject * obj0 = 0 ;
42165 PyObject * obj1 = 0 ;
42166
42167 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42169 if (SWIG_arg_fail(1)) SWIG_fail;
42170 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42171 if (SWIG_arg_fail(2)) SWIG_fail;
42172 {
42173 PyThreadState* __tstate = wxPyBeginAllowThreads();
42174 result = (arg1)->GetItemPosition(arg2);
42175
42176 wxPyEndAllowThreads(__tstate);
42177 if (PyErr_Occurred()) SWIG_fail;
42178 }
42179 {
42180 wxGBPosition * resultptr;
42181 resultptr = new wxGBPosition((wxGBPosition &)(result));
42182 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42183 }
42184 return resultobj;
42185 fail:
42186 return NULL;
42187 }
42188
42189
42190 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42191 PyObject *resultobj;
42192 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42193 size_t arg2 ;
42194 wxGBPosition result;
42195 PyObject * obj0 = 0 ;
42196 PyObject * obj1 = 0 ;
42197
42198 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42200 if (SWIG_arg_fail(1)) SWIG_fail;
42201 {
42202 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42203 if (SWIG_arg_fail(2)) SWIG_fail;
42204 }
42205 {
42206 PyThreadState* __tstate = wxPyBeginAllowThreads();
42207 result = (arg1)->GetItemPosition(arg2);
42208
42209 wxPyEndAllowThreads(__tstate);
42210 if (PyErr_Occurred()) SWIG_fail;
42211 }
42212 {
42213 wxGBPosition * resultptr;
42214 resultptr = new wxGBPosition((wxGBPosition &)(result));
42215 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42216 }
42217 return resultobj;
42218 fail:
42219 return NULL;
42220 }
42221
42222
42223 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
42224 int argc;
42225 PyObject *argv[3];
42226 int ii;
42227
42228 argc = PyObject_Length(args);
42229 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42230 argv[ii] = PyTuple_GetItem(args,ii);
42231 }
42232 if (argc == 2) {
42233 int _v;
42234 {
42235 void *ptr;
42236 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42237 _v = 0;
42238 PyErr_Clear();
42239 } else {
42240 _v = 1;
42241 }
42242 }
42243 if (_v) {
42244 {
42245 void *ptr;
42246 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42247 _v = 0;
42248 PyErr_Clear();
42249 } else {
42250 _v = 1;
42251 }
42252 }
42253 if (_v) {
42254 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
42255 }
42256 }
42257 }
42258 if (argc == 2) {
42259 int _v;
42260 {
42261 void *ptr;
42262 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42263 _v = 0;
42264 PyErr_Clear();
42265 } else {
42266 _v = 1;
42267 }
42268 }
42269 if (_v) {
42270 {
42271 void *ptr;
42272 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42273 _v = 0;
42274 PyErr_Clear();
42275 } else {
42276 _v = 1;
42277 }
42278 }
42279 if (_v) {
42280 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
42281 }
42282 }
42283 }
42284 if (argc == 2) {
42285 int _v;
42286 {
42287 void *ptr;
42288 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42289 _v = 0;
42290 PyErr_Clear();
42291 } else {
42292 _v = 1;
42293 }
42294 }
42295 if (_v) {
42296 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42297 if (_v) {
42298 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
42299 }
42300 }
42301 }
42302
42303 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
42304 return NULL;
42305 }
42306
42307
42308 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42309 PyObject *resultobj;
42310 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42311 wxWindow *arg2 = (wxWindow *) 0 ;
42312 wxGBPosition *arg3 = 0 ;
42313 bool result;
42314 wxGBPosition temp3 ;
42315 PyObject * obj0 = 0 ;
42316 PyObject * obj1 = 0 ;
42317 PyObject * obj2 = 0 ;
42318
42319 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42321 if (SWIG_arg_fail(1)) SWIG_fail;
42322 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42323 if (SWIG_arg_fail(2)) SWIG_fail;
42324 {
42325 arg3 = &temp3;
42326 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42327 }
42328 {
42329 PyThreadState* __tstate = wxPyBeginAllowThreads();
42330 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42331
42332 wxPyEndAllowThreads(__tstate);
42333 if (PyErr_Occurred()) SWIG_fail;
42334 }
42335 {
42336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42337 }
42338 return resultobj;
42339 fail:
42340 return NULL;
42341 }
42342
42343
42344 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42345 PyObject *resultobj;
42346 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42347 wxSizer *arg2 = (wxSizer *) 0 ;
42348 wxGBPosition *arg3 = 0 ;
42349 bool result;
42350 wxGBPosition temp3 ;
42351 PyObject * obj0 = 0 ;
42352 PyObject * obj1 = 0 ;
42353 PyObject * obj2 = 0 ;
42354
42355 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42357 if (SWIG_arg_fail(1)) SWIG_fail;
42358 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42359 if (SWIG_arg_fail(2)) SWIG_fail;
42360 {
42361 arg3 = &temp3;
42362 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42363 }
42364 {
42365 PyThreadState* __tstate = wxPyBeginAllowThreads();
42366 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42367
42368 wxPyEndAllowThreads(__tstate);
42369 if (PyErr_Occurred()) SWIG_fail;
42370 }
42371 {
42372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42373 }
42374 return resultobj;
42375 fail:
42376 return NULL;
42377 }
42378
42379
42380 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42381 PyObject *resultobj;
42382 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42383 size_t arg2 ;
42384 wxGBPosition *arg3 = 0 ;
42385 bool result;
42386 wxGBPosition temp3 ;
42387 PyObject * obj0 = 0 ;
42388 PyObject * obj1 = 0 ;
42389 PyObject * obj2 = 0 ;
42390
42391 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42393 if (SWIG_arg_fail(1)) SWIG_fail;
42394 {
42395 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42396 if (SWIG_arg_fail(2)) SWIG_fail;
42397 }
42398 {
42399 arg3 = &temp3;
42400 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42401 }
42402 {
42403 PyThreadState* __tstate = wxPyBeginAllowThreads();
42404 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42405
42406 wxPyEndAllowThreads(__tstate);
42407 if (PyErr_Occurred()) SWIG_fail;
42408 }
42409 {
42410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42411 }
42412 return resultobj;
42413 fail:
42414 return NULL;
42415 }
42416
42417
42418 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
42419 int argc;
42420 PyObject *argv[4];
42421 int ii;
42422
42423 argc = PyObject_Length(args);
42424 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42425 argv[ii] = PyTuple_GetItem(args,ii);
42426 }
42427 if (argc == 3) {
42428 int _v;
42429 {
42430 void *ptr;
42431 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42432 _v = 0;
42433 PyErr_Clear();
42434 } else {
42435 _v = 1;
42436 }
42437 }
42438 if (_v) {
42439 {
42440 void *ptr;
42441 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42442 _v = 0;
42443 PyErr_Clear();
42444 } else {
42445 _v = 1;
42446 }
42447 }
42448 if (_v) {
42449 {
42450 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42451 }
42452 if (_v) {
42453 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
42454 }
42455 }
42456 }
42457 }
42458 if (argc == 3) {
42459 int _v;
42460 {
42461 void *ptr;
42462 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42463 _v = 0;
42464 PyErr_Clear();
42465 } else {
42466 _v = 1;
42467 }
42468 }
42469 if (_v) {
42470 {
42471 void *ptr;
42472 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42473 _v = 0;
42474 PyErr_Clear();
42475 } else {
42476 _v = 1;
42477 }
42478 }
42479 if (_v) {
42480 {
42481 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42482 }
42483 if (_v) {
42484 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
42485 }
42486 }
42487 }
42488 }
42489 if (argc == 3) {
42490 int _v;
42491 {
42492 void *ptr;
42493 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42494 _v = 0;
42495 PyErr_Clear();
42496 } else {
42497 _v = 1;
42498 }
42499 }
42500 if (_v) {
42501 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42502 if (_v) {
42503 {
42504 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42505 }
42506 if (_v) {
42507 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
42508 }
42509 }
42510 }
42511 }
42512
42513 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
42514 return NULL;
42515 }
42516
42517
42518 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42519 PyObject *resultobj;
42520 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42521 wxWindow *arg2 = (wxWindow *) 0 ;
42522 wxGBSpan result;
42523 PyObject * obj0 = 0 ;
42524 PyObject * obj1 = 0 ;
42525
42526 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42528 if (SWIG_arg_fail(1)) SWIG_fail;
42529 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42530 if (SWIG_arg_fail(2)) SWIG_fail;
42531 {
42532 PyThreadState* __tstate = wxPyBeginAllowThreads();
42533 result = (arg1)->GetItemSpan(arg2);
42534
42535 wxPyEndAllowThreads(__tstate);
42536 if (PyErr_Occurred()) SWIG_fail;
42537 }
42538 {
42539 wxGBSpan * resultptr;
42540 resultptr = new wxGBSpan((wxGBSpan &)(result));
42541 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42542 }
42543 return resultobj;
42544 fail:
42545 return NULL;
42546 }
42547
42548
42549 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42550 PyObject *resultobj;
42551 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42552 wxSizer *arg2 = (wxSizer *) 0 ;
42553 wxGBSpan result;
42554 PyObject * obj0 = 0 ;
42555 PyObject * obj1 = 0 ;
42556
42557 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42559 if (SWIG_arg_fail(1)) SWIG_fail;
42560 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42561 if (SWIG_arg_fail(2)) SWIG_fail;
42562 {
42563 PyThreadState* __tstate = wxPyBeginAllowThreads();
42564 result = (arg1)->GetItemSpan(arg2);
42565
42566 wxPyEndAllowThreads(__tstate);
42567 if (PyErr_Occurred()) SWIG_fail;
42568 }
42569 {
42570 wxGBSpan * resultptr;
42571 resultptr = new wxGBSpan((wxGBSpan &)(result));
42572 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42573 }
42574 return resultobj;
42575 fail:
42576 return NULL;
42577 }
42578
42579
42580 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42581 PyObject *resultobj;
42582 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42583 size_t arg2 ;
42584 wxGBSpan result;
42585 PyObject * obj0 = 0 ;
42586 PyObject * obj1 = 0 ;
42587
42588 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42590 if (SWIG_arg_fail(1)) SWIG_fail;
42591 {
42592 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42593 if (SWIG_arg_fail(2)) SWIG_fail;
42594 }
42595 {
42596 PyThreadState* __tstate = wxPyBeginAllowThreads();
42597 result = (arg1)->GetItemSpan(arg2);
42598
42599 wxPyEndAllowThreads(__tstate);
42600 if (PyErr_Occurred()) SWIG_fail;
42601 }
42602 {
42603 wxGBSpan * resultptr;
42604 resultptr = new wxGBSpan((wxGBSpan &)(result));
42605 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42606 }
42607 return resultobj;
42608 fail:
42609 return NULL;
42610 }
42611
42612
42613 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
42614 int argc;
42615 PyObject *argv[3];
42616 int ii;
42617
42618 argc = PyObject_Length(args);
42619 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42620 argv[ii] = PyTuple_GetItem(args,ii);
42621 }
42622 if (argc == 2) {
42623 int _v;
42624 {
42625 void *ptr;
42626 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42627 _v = 0;
42628 PyErr_Clear();
42629 } else {
42630 _v = 1;
42631 }
42632 }
42633 if (_v) {
42634 {
42635 void *ptr;
42636 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42637 _v = 0;
42638 PyErr_Clear();
42639 } else {
42640 _v = 1;
42641 }
42642 }
42643 if (_v) {
42644 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
42645 }
42646 }
42647 }
42648 if (argc == 2) {
42649 int _v;
42650 {
42651 void *ptr;
42652 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42653 _v = 0;
42654 PyErr_Clear();
42655 } else {
42656 _v = 1;
42657 }
42658 }
42659 if (_v) {
42660 {
42661 void *ptr;
42662 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42663 _v = 0;
42664 PyErr_Clear();
42665 } else {
42666 _v = 1;
42667 }
42668 }
42669 if (_v) {
42670 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
42671 }
42672 }
42673 }
42674 if (argc == 2) {
42675 int _v;
42676 {
42677 void *ptr;
42678 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42679 _v = 0;
42680 PyErr_Clear();
42681 } else {
42682 _v = 1;
42683 }
42684 }
42685 if (_v) {
42686 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42687 if (_v) {
42688 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
42689 }
42690 }
42691 }
42692
42693 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
42694 return NULL;
42695 }
42696
42697
42698 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42699 PyObject *resultobj;
42700 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42701 wxWindow *arg2 = (wxWindow *) 0 ;
42702 wxGBSpan *arg3 = 0 ;
42703 bool result;
42704 wxGBSpan temp3 ;
42705 PyObject * obj0 = 0 ;
42706 PyObject * obj1 = 0 ;
42707 PyObject * obj2 = 0 ;
42708
42709 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42711 if (SWIG_arg_fail(1)) SWIG_fail;
42712 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42713 if (SWIG_arg_fail(2)) SWIG_fail;
42714 {
42715 arg3 = &temp3;
42716 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42717 }
42718 {
42719 PyThreadState* __tstate = wxPyBeginAllowThreads();
42720 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42721
42722 wxPyEndAllowThreads(__tstate);
42723 if (PyErr_Occurred()) SWIG_fail;
42724 }
42725 {
42726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42727 }
42728 return resultobj;
42729 fail:
42730 return NULL;
42731 }
42732
42733
42734 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42735 PyObject *resultobj;
42736 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42737 wxSizer *arg2 = (wxSizer *) 0 ;
42738 wxGBSpan *arg3 = 0 ;
42739 bool result;
42740 wxGBSpan temp3 ;
42741 PyObject * obj0 = 0 ;
42742 PyObject * obj1 = 0 ;
42743 PyObject * obj2 = 0 ;
42744
42745 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42747 if (SWIG_arg_fail(1)) SWIG_fail;
42748 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42749 if (SWIG_arg_fail(2)) SWIG_fail;
42750 {
42751 arg3 = &temp3;
42752 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42753 }
42754 {
42755 PyThreadState* __tstate = wxPyBeginAllowThreads();
42756 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42757
42758 wxPyEndAllowThreads(__tstate);
42759 if (PyErr_Occurred()) SWIG_fail;
42760 }
42761 {
42762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42763 }
42764 return resultobj;
42765 fail:
42766 return NULL;
42767 }
42768
42769
42770 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42771 PyObject *resultobj;
42772 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42773 size_t arg2 ;
42774 wxGBSpan *arg3 = 0 ;
42775 bool result;
42776 wxGBSpan temp3 ;
42777 PyObject * obj0 = 0 ;
42778 PyObject * obj1 = 0 ;
42779 PyObject * obj2 = 0 ;
42780
42781 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42783 if (SWIG_arg_fail(1)) SWIG_fail;
42784 {
42785 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42786 if (SWIG_arg_fail(2)) SWIG_fail;
42787 }
42788 {
42789 arg3 = &temp3;
42790 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42791 }
42792 {
42793 PyThreadState* __tstate = wxPyBeginAllowThreads();
42794 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42795
42796 wxPyEndAllowThreads(__tstate);
42797 if (PyErr_Occurred()) SWIG_fail;
42798 }
42799 {
42800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42801 }
42802 return resultobj;
42803 fail:
42804 return NULL;
42805 }
42806
42807
42808 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
42809 int argc;
42810 PyObject *argv[4];
42811 int ii;
42812
42813 argc = PyObject_Length(args);
42814 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42815 argv[ii] = PyTuple_GetItem(args,ii);
42816 }
42817 if (argc == 3) {
42818 int _v;
42819 {
42820 void *ptr;
42821 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42822 _v = 0;
42823 PyErr_Clear();
42824 } else {
42825 _v = 1;
42826 }
42827 }
42828 if (_v) {
42829 {
42830 void *ptr;
42831 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42832 _v = 0;
42833 PyErr_Clear();
42834 } else {
42835 _v = 1;
42836 }
42837 }
42838 if (_v) {
42839 {
42840 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42841 }
42842 if (_v) {
42843 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
42844 }
42845 }
42846 }
42847 }
42848 if (argc == 3) {
42849 int _v;
42850 {
42851 void *ptr;
42852 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42853 _v = 0;
42854 PyErr_Clear();
42855 } else {
42856 _v = 1;
42857 }
42858 }
42859 if (_v) {
42860 {
42861 void *ptr;
42862 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42863 _v = 0;
42864 PyErr_Clear();
42865 } else {
42866 _v = 1;
42867 }
42868 }
42869 if (_v) {
42870 {
42871 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42872 }
42873 if (_v) {
42874 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
42875 }
42876 }
42877 }
42878 }
42879 if (argc == 3) {
42880 int _v;
42881 {
42882 void *ptr;
42883 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42884 _v = 0;
42885 PyErr_Clear();
42886 } else {
42887 _v = 1;
42888 }
42889 }
42890 if (_v) {
42891 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42892 if (_v) {
42893 {
42894 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42895 }
42896 if (_v) {
42897 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
42898 }
42899 }
42900 }
42901 }
42902
42903 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
42904 return NULL;
42905 }
42906
42907
42908 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
42909 PyObject *resultobj;
42910 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42911 wxWindow *arg2 = (wxWindow *) 0 ;
42912 wxGBSizerItem *result;
42913 PyObject * obj0 = 0 ;
42914 PyObject * obj1 = 0 ;
42915
42916 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
42917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42918 if (SWIG_arg_fail(1)) SWIG_fail;
42919 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42920 if (SWIG_arg_fail(2)) SWIG_fail;
42921 {
42922 PyThreadState* __tstate = wxPyBeginAllowThreads();
42923 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
42924
42925 wxPyEndAllowThreads(__tstate);
42926 if (PyErr_Occurred()) SWIG_fail;
42927 }
42928 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42929 return resultobj;
42930 fail:
42931 return NULL;
42932 }
42933
42934
42935 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
42936 PyObject *resultobj;
42937 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42938 wxSizer *arg2 = (wxSizer *) 0 ;
42939 wxGBSizerItem *result;
42940 PyObject * obj0 = 0 ;
42941 PyObject * obj1 = 0 ;
42942
42943 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
42944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42945 if (SWIG_arg_fail(1)) SWIG_fail;
42946 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42947 if (SWIG_arg_fail(2)) SWIG_fail;
42948 {
42949 PyThreadState* __tstate = wxPyBeginAllowThreads();
42950 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
42951
42952 wxPyEndAllowThreads(__tstate);
42953 if (PyErr_Occurred()) SWIG_fail;
42954 }
42955 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42956 return resultobj;
42957 fail:
42958 return NULL;
42959 }
42960
42961
42962 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
42963 int argc;
42964 PyObject *argv[3];
42965 int ii;
42966
42967 argc = PyObject_Length(args);
42968 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42969 argv[ii] = PyTuple_GetItem(args,ii);
42970 }
42971 if (argc == 2) {
42972 int _v;
42973 {
42974 void *ptr;
42975 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42976 _v = 0;
42977 PyErr_Clear();
42978 } else {
42979 _v = 1;
42980 }
42981 }
42982 if (_v) {
42983 {
42984 void *ptr;
42985 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42986 _v = 0;
42987 PyErr_Clear();
42988 } else {
42989 _v = 1;
42990 }
42991 }
42992 if (_v) {
42993 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
42994 }
42995 }
42996 }
42997 if (argc == 2) {
42998 int _v;
42999 {
43000 void *ptr;
43001 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43002 _v = 0;
43003 PyErr_Clear();
43004 } else {
43005 _v = 1;
43006 }
43007 }
43008 if (_v) {
43009 {
43010 void *ptr;
43011 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43012 _v = 0;
43013 PyErr_Clear();
43014 } else {
43015 _v = 1;
43016 }
43017 }
43018 if (_v) {
43019 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43020 }
43021 }
43022 }
43023
43024 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
43025 return NULL;
43026 }
43027
43028
43029 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
43030 PyObject *resultobj;
43031 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43032 wxGBPosition *arg2 = 0 ;
43033 wxGBSizerItem *result;
43034 wxGBPosition temp2 ;
43035 PyObject * obj0 = 0 ;
43036 PyObject * obj1 = 0 ;
43037 char *kwnames[] = {
43038 (char *) "self",(char *) "pos", NULL
43039 };
43040
43041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
43042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43043 if (SWIG_arg_fail(1)) SWIG_fail;
43044 {
43045 arg2 = &temp2;
43046 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43047 }
43048 {
43049 PyThreadState* __tstate = wxPyBeginAllowThreads();
43050 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
43051
43052 wxPyEndAllowThreads(__tstate);
43053 if (PyErr_Occurred()) SWIG_fail;
43054 }
43055 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43056 return resultobj;
43057 fail:
43058 return NULL;
43059 }
43060
43061
43062 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
43063 PyObject *resultobj;
43064 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43065 wxPoint *arg2 = 0 ;
43066 wxGBSizerItem *result;
43067 wxPoint temp2 ;
43068 PyObject * obj0 = 0 ;
43069 PyObject * obj1 = 0 ;
43070 char *kwnames[] = {
43071 (char *) "self",(char *) "pt", NULL
43072 };
43073
43074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
43075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43076 if (SWIG_arg_fail(1)) SWIG_fail;
43077 {
43078 arg2 = &temp2;
43079 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
43080 }
43081 {
43082 PyThreadState* __tstate = wxPyBeginAllowThreads();
43083 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
43084
43085 wxPyEndAllowThreads(__tstate);
43086 if (PyErr_Occurred()) SWIG_fail;
43087 }
43088 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43089 return resultobj;
43090 fail:
43091 return NULL;
43092 }
43093
43094
43095 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
43096 PyObject *resultobj;
43097 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43098 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43099 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
43100 bool result;
43101 PyObject * obj0 = 0 ;
43102 PyObject * obj1 = 0 ;
43103 PyObject * obj2 = 0 ;
43104 char *kwnames[] = {
43105 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
43106 };
43107
43108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
43109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43110 if (SWIG_arg_fail(1)) SWIG_fail;
43111 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43112 if (SWIG_arg_fail(2)) SWIG_fail;
43113 if (obj2) {
43114 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43115 if (SWIG_arg_fail(3)) SWIG_fail;
43116 }
43117 {
43118 PyThreadState* __tstate = wxPyBeginAllowThreads();
43119 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
43120
43121 wxPyEndAllowThreads(__tstate);
43122 if (PyErr_Occurred()) SWIG_fail;
43123 }
43124 {
43125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43126 }
43127 return resultobj;
43128 fail:
43129 return NULL;
43130 }
43131
43132
43133 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
43134 PyObject *resultobj;
43135 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43136 wxGBPosition *arg2 = 0 ;
43137 wxGBSpan *arg3 = 0 ;
43138 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
43139 bool result;
43140 wxGBPosition temp2 ;
43141 wxGBSpan temp3 ;
43142 PyObject * obj0 = 0 ;
43143 PyObject * obj1 = 0 ;
43144 PyObject * obj2 = 0 ;
43145 PyObject * obj3 = 0 ;
43146 char *kwnames[] = {
43147 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
43148 };
43149
43150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43152 if (SWIG_arg_fail(1)) SWIG_fail;
43153 {
43154 arg2 = &temp2;
43155 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43156 }
43157 {
43158 arg3 = &temp3;
43159 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43160 }
43161 if (obj3) {
43162 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43163 if (SWIG_arg_fail(4)) SWIG_fail;
43164 }
43165 {
43166 PyThreadState* __tstate = wxPyBeginAllowThreads();
43167 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
43168
43169 wxPyEndAllowThreads(__tstate);
43170 if (PyErr_Occurred()) SWIG_fail;
43171 }
43172 {
43173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43174 }
43175 return resultobj;
43176 fail:
43177 return NULL;
43178 }
43179
43180
43181 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
43182 PyObject *obj;
43183 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43184 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
43185 Py_INCREF(obj);
43186 return Py_BuildValue((char *)"");
43187 }
43188 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43189 PyObject *resultobj;
43190 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43191 wxRelationship arg2 ;
43192 wxWindow *arg3 = (wxWindow *) 0 ;
43193 wxEdge arg4 ;
43194 int arg5 = (int) 0 ;
43195 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
43196 PyObject * obj0 = 0 ;
43197 PyObject * obj1 = 0 ;
43198 PyObject * obj2 = 0 ;
43199 PyObject * obj3 = 0 ;
43200 PyObject * obj4 = 0 ;
43201 PyObject * obj5 = 0 ;
43202 char *kwnames[] = {
43203 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
43204 };
43205
43206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43208 if (SWIG_arg_fail(1)) SWIG_fail;
43209 {
43210 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43211 if (SWIG_arg_fail(2)) SWIG_fail;
43212 }
43213 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43214 if (SWIG_arg_fail(3)) SWIG_fail;
43215 {
43216 arg4 = (wxEdge)(SWIG_As_int(obj3));
43217 if (SWIG_arg_fail(4)) SWIG_fail;
43218 }
43219 if (obj4) {
43220 {
43221 arg5 = (int)(SWIG_As_int(obj4));
43222 if (SWIG_arg_fail(5)) SWIG_fail;
43223 }
43224 }
43225 if (obj5) {
43226 {
43227 arg6 = (int)(SWIG_As_int(obj5));
43228 if (SWIG_arg_fail(6)) SWIG_fail;
43229 }
43230 }
43231 {
43232 PyThreadState* __tstate = wxPyBeginAllowThreads();
43233 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
43234
43235 wxPyEndAllowThreads(__tstate);
43236 if (PyErr_Occurred()) SWIG_fail;
43237 }
43238 Py_INCREF(Py_None); resultobj = Py_None;
43239 return resultobj;
43240 fail:
43241 return NULL;
43242 }
43243
43244
43245 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
43246 PyObject *resultobj;
43247 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43248 wxWindow *arg2 = (wxWindow *) 0 ;
43249 int arg3 = (int) 0 ;
43250 PyObject * obj0 = 0 ;
43251 PyObject * obj1 = 0 ;
43252 PyObject * obj2 = 0 ;
43253 char *kwnames[] = {
43254 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43255 };
43256
43257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43259 if (SWIG_arg_fail(1)) SWIG_fail;
43260 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43261 if (SWIG_arg_fail(2)) SWIG_fail;
43262 if (obj2) {
43263 {
43264 arg3 = (int)(SWIG_As_int(obj2));
43265 if (SWIG_arg_fail(3)) SWIG_fail;
43266 }
43267 }
43268 {
43269 PyThreadState* __tstate = wxPyBeginAllowThreads();
43270 (arg1)->LeftOf(arg2,arg3);
43271
43272 wxPyEndAllowThreads(__tstate);
43273 if (PyErr_Occurred()) SWIG_fail;
43274 }
43275 Py_INCREF(Py_None); resultobj = Py_None;
43276 return resultobj;
43277 fail:
43278 return NULL;
43279 }
43280
43281
43282 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
43283 PyObject *resultobj;
43284 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43285 wxWindow *arg2 = (wxWindow *) 0 ;
43286 int arg3 = (int) 0 ;
43287 PyObject * obj0 = 0 ;
43288 PyObject * obj1 = 0 ;
43289 PyObject * obj2 = 0 ;
43290 char *kwnames[] = {
43291 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43292 };
43293
43294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43296 if (SWIG_arg_fail(1)) SWIG_fail;
43297 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43298 if (SWIG_arg_fail(2)) SWIG_fail;
43299 if (obj2) {
43300 {
43301 arg3 = (int)(SWIG_As_int(obj2));
43302 if (SWIG_arg_fail(3)) SWIG_fail;
43303 }
43304 }
43305 {
43306 PyThreadState* __tstate = wxPyBeginAllowThreads();
43307 (arg1)->RightOf(arg2,arg3);
43308
43309 wxPyEndAllowThreads(__tstate);
43310 if (PyErr_Occurred()) SWIG_fail;
43311 }
43312 Py_INCREF(Py_None); resultobj = Py_None;
43313 return resultobj;
43314 fail:
43315 return NULL;
43316 }
43317
43318
43319 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
43320 PyObject *resultobj;
43321 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43322 wxWindow *arg2 = (wxWindow *) 0 ;
43323 int arg3 = (int) 0 ;
43324 PyObject * obj0 = 0 ;
43325 PyObject * obj1 = 0 ;
43326 PyObject * obj2 = 0 ;
43327 char *kwnames[] = {
43328 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43329 };
43330
43331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
43332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43333 if (SWIG_arg_fail(1)) SWIG_fail;
43334 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43335 if (SWIG_arg_fail(2)) SWIG_fail;
43336 if (obj2) {
43337 {
43338 arg3 = (int)(SWIG_As_int(obj2));
43339 if (SWIG_arg_fail(3)) SWIG_fail;
43340 }
43341 }
43342 {
43343 PyThreadState* __tstate = wxPyBeginAllowThreads();
43344 (arg1)->Above(arg2,arg3);
43345
43346 wxPyEndAllowThreads(__tstate);
43347 if (PyErr_Occurred()) SWIG_fail;
43348 }
43349 Py_INCREF(Py_None); resultobj = Py_None;
43350 return resultobj;
43351 fail:
43352 return NULL;
43353 }
43354
43355
43356 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
43357 PyObject *resultobj;
43358 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43359 wxWindow *arg2 = (wxWindow *) 0 ;
43360 int arg3 = (int) 0 ;
43361 PyObject * obj0 = 0 ;
43362 PyObject * obj1 = 0 ;
43363 PyObject * obj2 = 0 ;
43364 char *kwnames[] = {
43365 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43366 };
43367
43368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
43369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43370 if (SWIG_arg_fail(1)) SWIG_fail;
43371 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43372 if (SWIG_arg_fail(2)) SWIG_fail;
43373 if (obj2) {
43374 {
43375 arg3 = (int)(SWIG_As_int(obj2));
43376 if (SWIG_arg_fail(3)) SWIG_fail;
43377 }
43378 }
43379 {
43380 PyThreadState* __tstate = wxPyBeginAllowThreads();
43381 (arg1)->Below(arg2,arg3);
43382
43383 wxPyEndAllowThreads(__tstate);
43384 if (PyErr_Occurred()) SWIG_fail;
43385 }
43386 Py_INCREF(Py_None); resultobj = Py_None;
43387 return resultobj;
43388 fail:
43389 return NULL;
43390 }
43391
43392
43393 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
43394 PyObject *resultobj;
43395 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43396 wxWindow *arg2 = (wxWindow *) 0 ;
43397 wxEdge arg3 ;
43398 int arg4 = (int) 0 ;
43399 PyObject * obj0 = 0 ;
43400 PyObject * obj1 = 0 ;
43401 PyObject * obj2 = 0 ;
43402 PyObject * obj3 = 0 ;
43403 char *kwnames[] = {
43404 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
43405 };
43406
43407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43409 if (SWIG_arg_fail(1)) SWIG_fail;
43410 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43411 if (SWIG_arg_fail(2)) SWIG_fail;
43412 {
43413 arg3 = (wxEdge)(SWIG_As_int(obj2));
43414 if (SWIG_arg_fail(3)) SWIG_fail;
43415 }
43416 if (obj3) {
43417 {
43418 arg4 = (int)(SWIG_As_int(obj3));
43419 if (SWIG_arg_fail(4)) SWIG_fail;
43420 }
43421 }
43422 {
43423 PyThreadState* __tstate = wxPyBeginAllowThreads();
43424 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
43425
43426 wxPyEndAllowThreads(__tstate);
43427 if (PyErr_Occurred()) SWIG_fail;
43428 }
43429 Py_INCREF(Py_None); resultobj = Py_None;
43430 return resultobj;
43431 fail:
43432 return NULL;
43433 }
43434
43435
43436 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
43437 PyObject *resultobj;
43438 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43439 wxWindow *arg2 = (wxWindow *) 0 ;
43440 wxEdge arg3 ;
43441 int arg4 ;
43442 PyObject * obj0 = 0 ;
43443 PyObject * obj1 = 0 ;
43444 PyObject * obj2 = 0 ;
43445 PyObject * obj3 = 0 ;
43446 char *kwnames[] = {
43447 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
43448 };
43449
43450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43452 if (SWIG_arg_fail(1)) SWIG_fail;
43453 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43454 if (SWIG_arg_fail(2)) SWIG_fail;
43455 {
43456 arg3 = (wxEdge)(SWIG_As_int(obj2));
43457 if (SWIG_arg_fail(3)) SWIG_fail;
43458 }
43459 {
43460 arg4 = (int)(SWIG_As_int(obj3));
43461 if (SWIG_arg_fail(4)) SWIG_fail;
43462 }
43463 {
43464 PyThreadState* __tstate = wxPyBeginAllowThreads();
43465 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
43466
43467 wxPyEndAllowThreads(__tstate);
43468 if (PyErr_Occurred()) SWIG_fail;
43469 }
43470 Py_INCREF(Py_None); resultobj = Py_None;
43471 return resultobj;
43472 fail:
43473 return NULL;
43474 }
43475
43476
43477 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
43478 PyObject *resultobj;
43479 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43480 int arg2 ;
43481 PyObject * obj0 = 0 ;
43482 PyObject * obj1 = 0 ;
43483 char *kwnames[] = {
43484 (char *) "self",(char *) "val", NULL
43485 };
43486
43487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
43488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43489 if (SWIG_arg_fail(1)) SWIG_fail;
43490 {
43491 arg2 = (int)(SWIG_As_int(obj1));
43492 if (SWIG_arg_fail(2)) SWIG_fail;
43493 }
43494 {
43495 PyThreadState* __tstate = wxPyBeginAllowThreads();
43496 (arg1)->Absolute(arg2);
43497
43498 wxPyEndAllowThreads(__tstate);
43499 if (PyErr_Occurred()) SWIG_fail;
43500 }
43501 Py_INCREF(Py_None); resultobj = Py_None;
43502 return resultobj;
43503 fail:
43504 return NULL;
43505 }
43506
43507
43508 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
43509 PyObject *resultobj;
43510 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43511 PyObject * obj0 = 0 ;
43512 char *kwnames[] = {
43513 (char *) "self", NULL
43514 };
43515
43516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
43517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43518 if (SWIG_arg_fail(1)) SWIG_fail;
43519 {
43520 PyThreadState* __tstate = wxPyBeginAllowThreads();
43521 (arg1)->Unconstrained();
43522
43523 wxPyEndAllowThreads(__tstate);
43524 if (PyErr_Occurred()) SWIG_fail;
43525 }
43526 Py_INCREF(Py_None); resultobj = Py_None;
43527 return resultobj;
43528 fail:
43529 return NULL;
43530 }
43531
43532
43533 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
43534 PyObject *resultobj;
43535 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43536 PyObject * obj0 = 0 ;
43537 char *kwnames[] = {
43538 (char *) "self", NULL
43539 };
43540
43541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
43542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43543 if (SWIG_arg_fail(1)) SWIG_fail;
43544 {
43545 PyThreadState* __tstate = wxPyBeginAllowThreads();
43546 (arg1)->AsIs();
43547
43548 wxPyEndAllowThreads(__tstate);
43549 if (PyErr_Occurred()) SWIG_fail;
43550 }
43551 Py_INCREF(Py_None); resultobj = Py_None;
43552 return resultobj;
43553 fail:
43554 return NULL;
43555 }
43556
43557
43558 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43559 PyObject *resultobj;
43560 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43561 wxWindow *result;
43562 PyObject * obj0 = 0 ;
43563 char *kwnames[] = {
43564 (char *) "self", NULL
43565 };
43566
43567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
43568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43569 if (SWIG_arg_fail(1)) SWIG_fail;
43570 {
43571 PyThreadState* __tstate = wxPyBeginAllowThreads();
43572 result = (wxWindow *)(arg1)->GetOtherWindow();
43573
43574 wxPyEndAllowThreads(__tstate);
43575 if (PyErr_Occurred()) SWIG_fail;
43576 }
43577 {
43578 resultobj = wxPyMake_wxObject(result, 0);
43579 }
43580 return resultobj;
43581 fail:
43582 return NULL;
43583 }
43584
43585
43586 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43587 PyObject *resultobj;
43588 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43589 wxEdge result;
43590 PyObject * obj0 = 0 ;
43591 char *kwnames[] = {
43592 (char *) "self", NULL
43593 };
43594
43595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
43596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43597 if (SWIG_arg_fail(1)) SWIG_fail;
43598 {
43599 PyThreadState* __tstate = wxPyBeginAllowThreads();
43600 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
43601
43602 wxPyEndAllowThreads(__tstate);
43603 if (PyErr_Occurred()) SWIG_fail;
43604 }
43605 resultobj = SWIG_From_int((result));
43606 return resultobj;
43607 fail:
43608 return NULL;
43609 }
43610
43611
43612 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43613 PyObject *resultobj;
43614 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43615 wxEdge arg2 ;
43616 PyObject * obj0 = 0 ;
43617 PyObject * obj1 = 0 ;
43618 char *kwnames[] = {
43619 (char *) "self",(char *) "which", NULL
43620 };
43621
43622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
43623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43624 if (SWIG_arg_fail(1)) SWIG_fail;
43625 {
43626 arg2 = (wxEdge)(SWIG_As_int(obj1));
43627 if (SWIG_arg_fail(2)) SWIG_fail;
43628 }
43629 {
43630 PyThreadState* __tstate = wxPyBeginAllowThreads();
43631 (arg1)->SetEdge((wxEdge )arg2);
43632
43633 wxPyEndAllowThreads(__tstate);
43634 if (PyErr_Occurred()) SWIG_fail;
43635 }
43636 Py_INCREF(Py_None); resultobj = Py_None;
43637 return resultobj;
43638 fail:
43639 return NULL;
43640 }
43641
43642
43643 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
43644 PyObject *resultobj;
43645 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43646 int arg2 ;
43647 PyObject * obj0 = 0 ;
43648 PyObject * obj1 = 0 ;
43649 char *kwnames[] = {
43650 (char *) "self",(char *) "v", NULL
43651 };
43652
43653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
43654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43655 if (SWIG_arg_fail(1)) SWIG_fail;
43656 {
43657 arg2 = (int)(SWIG_As_int(obj1));
43658 if (SWIG_arg_fail(2)) SWIG_fail;
43659 }
43660 {
43661 PyThreadState* __tstate = wxPyBeginAllowThreads();
43662 (arg1)->SetValue(arg2);
43663
43664 wxPyEndAllowThreads(__tstate);
43665 if (PyErr_Occurred()) SWIG_fail;
43666 }
43667 Py_INCREF(Py_None); resultobj = Py_None;
43668 return resultobj;
43669 fail:
43670 return NULL;
43671 }
43672
43673
43674 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
43675 PyObject *resultobj;
43676 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43677 int result;
43678 PyObject * obj0 = 0 ;
43679 char *kwnames[] = {
43680 (char *) "self", NULL
43681 };
43682
43683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
43684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43685 if (SWIG_arg_fail(1)) SWIG_fail;
43686 {
43687 PyThreadState* __tstate = wxPyBeginAllowThreads();
43688 result = (int)(arg1)->GetMargin();
43689
43690 wxPyEndAllowThreads(__tstate);
43691 if (PyErr_Occurred()) SWIG_fail;
43692 }
43693 {
43694 resultobj = SWIG_From_int((int)(result));
43695 }
43696 return resultobj;
43697 fail:
43698 return NULL;
43699 }
43700
43701
43702 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
43703 PyObject *resultobj;
43704 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43705 int arg2 ;
43706 PyObject * obj0 = 0 ;
43707 PyObject * obj1 = 0 ;
43708 char *kwnames[] = {
43709 (char *) "self",(char *) "m", NULL
43710 };
43711
43712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
43713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43714 if (SWIG_arg_fail(1)) SWIG_fail;
43715 {
43716 arg2 = (int)(SWIG_As_int(obj1));
43717 if (SWIG_arg_fail(2)) SWIG_fail;
43718 }
43719 {
43720 PyThreadState* __tstate = wxPyBeginAllowThreads();
43721 (arg1)->SetMargin(arg2);
43722
43723 wxPyEndAllowThreads(__tstate);
43724 if (PyErr_Occurred()) SWIG_fail;
43725 }
43726 Py_INCREF(Py_None); resultobj = Py_None;
43727 return resultobj;
43728 fail:
43729 return NULL;
43730 }
43731
43732
43733 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
43734 PyObject *resultobj;
43735 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43736 int result;
43737 PyObject * obj0 = 0 ;
43738 char *kwnames[] = {
43739 (char *) "self", NULL
43740 };
43741
43742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
43743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43744 if (SWIG_arg_fail(1)) SWIG_fail;
43745 {
43746 PyThreadState* __tstate = wxPyBeginAllowThreads();
43747 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
43748
43749 wxPyEndAllowThreads(__tstate);
43750 if (PyErr_Occurred()) SWIG_fail;
43751 }
43752 {
43753 resultobj = SWIG_From_int((int)(result));
43754 }
43755 return resultobj;
43756 fail:
43757 return NULL;
43758 }
43759
43760
43761 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
43762 PyObject *resultobj;
43763 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43764 int result;
43765 PyObject * obj0 = 0 ;
43766 char *kwnames[] = {
43767 (char *) "self", NULL
43768 };
43769
43770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
43771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43772 if (SWIG_arg_fail(1)) SWIG_fail;
43773 {
43774 PyThreadState* __tstate = wxPyBeginAllowThreads();
43775 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
43776
43777 wxPyEndAllowThreads(__tstate);
43778 if (PyErr_Occurred()) SWIG_fail;
43779 }
43780 {
43781 resultobj = SWIG_From_int((int)(result));
43782 }
43783 return resultobj;
43784 fail:
43785 return NULL;
43786 }
43787
43788
43789 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43790 PyObject *resultobj;
43791 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43792 int result;
43793 PyObject * obj0 = 0 ;
43794 char *kwnames[] = {
43795 (char *) "self", NULL
43796 };
43797
43798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
43799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43800 if (SWIG_arg_fail(1)) SWIG_fail;
43801 {
43802 PyThreadState* __tstate = wxPyBeginAllowThreads();
43803 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
43804
43805 wxPyEndAllowThreads(__tstate);
43806 if (PyErr_Occurred()) SWIG_fail;
43807 }
43808 {
43809 resultobj = SWIG_From_int((int)(result));
43810 }
43811 return resultobj;
43812 fail:
43813 return NULL;
43814 }
43815
43816
43817 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
43818 PyObject *resultobj;
43819 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43820 bool result;
43821 PyObject * obj0 = 0 ;
43822 char *kwnames[] = {
43823 (char *) "self", NULL
43824 };
43825
43826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
43827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43828 if (SWIG_arg_fail(1)) SWIG_fail;
43829 {
43830 PyThreadState* __tstate = wxPyBeginAllowThreads();
43831 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
43832
43833 wxPyEndAllowThreads(__tstate);
43834 if (PyErr_Occurred()) SWIG_fail;
43835 }
43836 {
43837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43838 }
43839 return resultobj;
43840 fail:
43841 return NULL;
43842 }
43843
43844
43845 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
43846 PyObject *resultobj;
43847 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43848 bool arg2 ;
43849 PyObject * obj0 = 0 ;
43850 PyObject * obj1 = 0 ;
43851 char *kwnames[] = {
43852 (char *) "self",(char *) "d", NULL
43853 };
43854
43855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
43856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43857 if (SWIG_arg_fail(1)) SWIG_fail;
43858 {
43859 arg2 = (bool)(SWIG_As_bool(obj1));
43860 if (SWIG_arg_fail(2)) SWIG_fail;
43861 }
43862 {
43863 PyThreadState* __tstate = wxPyBeginAllowThreads();
43864 (arg1)->SetDone(arg2);
43865
43866 wxPyEndAllowThreads(__tstate);
43867 if (PyErr_Occurred()) SWIG_fail;
43868 }
43869 Py_INCREF(Py_None); resultobj = Py_None;
43870 return resultobj;
43871 fail:
43872 return NULL;
43873 }
43874
43875
43876 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
43877 PyObject *resultobj;
43878 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43879 wxRelationship result;
43880 PyObject * obj0 = 0 ;
43881 char *kwnames[] = {
43882 (char *) "self", NULL
43883 };
43884
43885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
43886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43887 if (SWIG_arg_fail(1)) SWIG_fail;
43888 {
43889 PyThreadState* __tstate = wxPyBeginAllowThreads();
43890 result = (wxRelationship)(arg1)->GetRelationship();
43891
43892 wxPyEndAllowThreads(__tstate);
43893 if (PyErr_Occurred()) SWIG_fail;
43894 }
43895 resultobj = SWIG_From_int((result));
43896 return resultobj;
43897 fail:
43898 return NULL;
43899 }
43900
43901
43902 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
43903 PyObject *resultobj;
43904 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43905 wxRelationship arg2 ;
43906 PyObject * obj0 = 0 ;
43907 PyObject * obj1 = 0 ;
43908 char *kwnames[] = {
43909 (char *) "self",(char *) "r", NULL
43910 };
43911
43912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
43913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43914 if (SWIG_arg_fail(1)) SWIG_fail;
43915 {
43916 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43917 if (SWIG_arg_fail(2)) SWIG_fail;
43918 }
43919 {
43920 PyThreadState* __tstate = wxPyBeginAllowThreads();
43921 (arg1)->SetRelationship((wxRelationship )arg2);
43922
43923 wxPyEndAllowThreads(__tstate);
43924 if (PyErr_Occurred()) SWIG_fail;
43925 }
43926 Py_INCREF(Py_None); resultobj = Py_None;
43927 return resultobj;
43928 fail:
43929 return NULL;
43930 }
43931
43932
43933 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
43934 PyObject *resultobj;
43935 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43936 wxWindow *arg2 = (wxWindow *) 0 ;
43937 bool result;
43938 PyObject * obj0 = 0 ;
43939 PyObject * obj1 = 0 ;
43940 char *kwnames[] = {
43941 (char *) "self",(char *) "otherW", NULL
43942 };
43943
43944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
43945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43946 if (SWIG_arg_fail(1)) SWIG_fail;
43947 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43948 if (SWIG_arg_fail(2)) SWIG_fail;
43949 {
43950 PyThreadState* __tstate = wxPyBeginAllowThreads();
43951 result = (bool)(arg1)->ResetIfWin(arg2);
43952
43953 wxPyEndAllowThreads(__tstate);
43954 if (PyErr_Occurred()) SWIG_fail;
43955 }
43956 {
43957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43958 }
43959 return resultobj;
43960 fail:
43961 return NULL;
43962 }
43963
43964
43965 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
43966 PyObject *resultobj;
43967 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43968 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
43969 wxWindow *arg3 = (wxWindow *) 0 ;
43970 bool result;
43971 PyObject * obj0 = 0 ;
43972 PyObject * obj1 = 0 ;
43973 PyObject * obj2 = 0 ;
43974 char *kwnames[] = {
43975 (char *) "self",(char *) "constraints",(char *) "win", NULL
43976 };
43977
43978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
43979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43980 if (SWIG_arg_fail(1)) SWIG_fail;
43981 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43982 if (SWIG_arg_fail(2)) SWIG_fail;
43983 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43984 if (SWIG_arg_fail(3)) SWIG_fail;
43985 {
43986 PyThreadState* __tstate = wxPyBeginAllowThreads();
43987 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
43988
43989 wxPyEndAllowThreads(__tstate);
43990 if (PyErr_Occurred()) SWIG_fail;
43991 }
43992 {
43993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43994 }
43995 return resultobj;
43996 fail:
43997 return NULL;
43998 }
43999
44000
44001 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44002 PyObject *resultobj;
44003 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44004 wxEdge arg2 ;
44005 wxWindow *arg3 = (wxWindow *) 0 ;
44006 wxWindow *arg4 = (wxWindow *) 0 ;
44007 int result;
44008 PyObject * obj0 = 0 ;
44009 PyObject * obj1 = 0 ;
44010 PyObject * obj2 = 0 ;
44011 PyObject * obj3 = 0 ;
44012 char *kwnames[] = {
44013 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44014 };
44015
44016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44018 if (SWIG_arg_fail(1)) SWIG_fail;
44019 {
44020 arg2 = (wxEdge)(SWIG_As_int(obj1));
44021 if (SWIG_arg_fail(2)) SWIG_fail;
44022 }
44023 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44024 if (SWIG_arg_fail(3)) SWIG_fail;
44025 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44026 if (SWIG_arg_fail(4)) SWIG_fail;
44027 {
44028 PyThreadState* __tstate = wxPyBeginAllowThreads();
44029 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
44030
44031 wxPyEndAllowThreads(__tstate);
44032 if (PyErr_Occurred()) SWIG_fail;
44033 }
44034 {
44035 resultobj = SWIG_From_int((int)(result));
44036 }
44037 return resultobj;
44038 fail:
44039 return NULL;
44040 }
44041
44042
44043 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
44044 PyObject *obj;
44045 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44046 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
44047 Py_INCREF(obj);
44048 return Py_BuildValue((char *)"");
44049 }
44050 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
44051 PyObject *resultobj;
44052 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44053 wxIndividualLayoutConstraint *result;
44054 PyObject * obj0 = 0 ;
44055 char *kwnames[] = {
44056 (char *) "self", NULL
44057 };
44058
44059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
44060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44061 if (SWIG_arg_fail(1)) SWIG_fail;
44062 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
44063
44064 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44065 return resultobj;
44066 fail:
44067 return NULL;
44068 }
44069
44070
44071 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
44072 PyObject *resultobj;
44073 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44074 wxIndividualLayoutConstraint *result;
44075 PyObject * obj0 = 0 ;
44076 char *kwnames[] = {
44077 (char *) "self", NULL
44078 };
44079
44080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
44081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44082 if (SWIG_arg_fail(1)) SWIG_fail;
44083 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
44084
44085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44086 return resultobj;
44087 fail:
44088 return NULL;
44089 }
44090
44091
44092 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
44093 PyObject *resultobj;
44094 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44095 wxIndividualLayoutConstraint *result;
44096 PyObject * obj0 = 0 ;
44097 char *kwnames[] = {
44098 (char *) "self", NULL
44099 };
44100
44101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
44102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44103 if (SWIG_arg_fail(1)) SWIG_fail;
44104 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
44105
44106 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44107 return resultobj;
44108 fail:
44109 return NULL;
44110 }
44111
44112
44113 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
44114 PyObject *resultobj;
44115 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44116 wxIndividualLayoutConstraint *result;
44117 PyObject * obj0 = 0 ;
44118 char *kwnames[] = {
44119 (char *) "self", NULL
44120 };
44121
44122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
44123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44124 if (SWIG_arg_fail(1)) SWIG_fail;
44125 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
44126
44127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44128 return resultobj;
44129 fail:
44130 return NULL;
44131 }
44132
44133
44134 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
44135 PyObject *resultobj;
44136 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44137 wxIndividualLayoutConstraint *result;
44138 PyObject * obj0 = 0 ;
44139 char *kwnames[] = {
44140 (char *) "self", NULL
44141 };
44142
44143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
44144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44145 if (SWIG_arg_fail(1)) SWIG_fail;
44146 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
44147
44148 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44149 return resultobj;
44150 fail:
44151 return NULL;
44152 }
44153
44154
44155 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
44156 PyObject *resultobj;
44157 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44158 wxIndividualLayoutConstraint *result;
44159 PyObject * obj0 = 0 ;
44160 char *kwnames[] = {
44161 (char *) "self", NULL
44162 };
44163
44164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
44165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44166 if (SWIG_arg_fail(1)) SWIG_fail;
44167 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
44168
44169 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44170 return resultobj;
44171 fail:
44172 return NULL;
44173 }
44174
44175
44176 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
44177 PyObject *resultobj;
44178 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44179 wxIndividualLayoutConstraint *result;
44180 PyObject * obj0 = 0 ;
44181 char *kwnames[] = {
44182 (char *) "self", NULL
44183 };
44184
44185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
44186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44187 if (SWIG_arg_fail(1)) SWIG_fail;
44188 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
44189
44190 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44191 return resultobj;
44192 fail:
44193 return NULL;
44194 }
44195
44196
44197 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
44198 PyObject *resultobj;
44199 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44200 wxIndividualLayoutConstraint *result;
44201 PyObject * obj0 = 0 ;
44202 char *kwnames[] = {
44203 (char *) "self", NULL
44204 };
44205
44206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
44207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44208 if (SWIG_arg_fail(1)) SWIG_fail;
44209 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
44210
44211 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44212 return resultobj;
44213 fail:
44214 return NULL;
44215 }
44216
44217
44218 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44219 PyObject *resultobj;
44220 wxLayoutConstraints *result;
44221 char *kwnames[] = {
44222 NULL
44223 };
44224
44225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
44226 {
44227 PyThreadState* __tstate = wxPyBeginAllowThreads();
44228 result = (wxLayoutConstraints *)new wxLayoutConstraints();
44229
44230 wxPyEndAllowThreads(__tstate);
44231 if (PyErr_Occurred()) SWIG_fail;
44232 }
44233 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
44234 return resultobj;
44235 fail:
44236 return NULL;
44237 }
44238
44239
44240 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44241 PyObject *resultobj;
44242 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44243 wxWindow *arg2 = (wxWindow *) 0 ;
44244 int *arg3 = (int *) 0 ;
44245 bool result;
44246 int temp3 ;
44247 int res3 = 0 ;
44248 PyObject * obj0 = 0 ;
44249 PyObject * obj1 = 0 ;
44250 char *kwnames[] = {
44251 (char *) "self",(char *) "win", NULL
44252 };
44253
44254 arg3 = &temp3; res3 = SWIG_NEWOBJ;
44255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
44256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44257 if (SWIG_arg_fail(1)) SWIG_fail;
44258 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44259 if (SWIG_arg_fail(2)) SWIG_fail;
44260 {
44261 PyThreadState* __tstate = wxPyBeginAllowThreads();
44262 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
44263
44264 wxPyEndAllowThreads(__tstate);
44265 if (PyErr_Occurred()) SWIG_fail;
44266 }
44267 {
44268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44269 }
44270 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
44271 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
44272 return resultobj;
44273 fail:
44274 return NULL;
44275 }
44276
44277
44278 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
44279 PyObject *resultobj;
44280 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44281 bool result;
44282 PyObject * obj0 = 0 ;
44283 char *kwnames[] = {
44284 (char *) "self", NULL
44285 };
44286
44287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
44288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44289 if (SWIG_arg_fail(1)) SWIG_fail;
44290 {
44291 PyThreadState* __tstate = wxPyBeginAllowThreads();
44292 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
44293
44294 wxPyEndAllowThreads(__tstate);
44295 if (PyErr_Occurred()) SWIG_fail;
44296 }
44297 {
44298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44299 }
44300 return resultobj;
44301 fail:
44302 return NULL;
44303 }
44304
44305
44306 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
44307 PyObject *obj;
44308 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44309 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
44310 Py_INCREF(obj);
44311 return Py_BuildValue((char *)"");
44312 }
44313 static PyMethodDef SwigMethods[] = {
44314 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
44315 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
44316 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44317 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44318 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
44319 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44320 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44321 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44322 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44323 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44324 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44325 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44326 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44327 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44328 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44329 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
44330 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
44331 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44332 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44333 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44334 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44335 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44336 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
44337 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
44338 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44339 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
44340 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44341 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44342 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44343 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44344 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44345 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44346 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44347 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44348 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44349 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44350 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44351 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44352 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
44353 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44354 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44355 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44356 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44357 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44358 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44359 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44360 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44361 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44362 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44363 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44364 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44365 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44366 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44367 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
44368 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44369 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
44370 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
44371 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
44372 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44373 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44374 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
44375 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44376 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
44377 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44378 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44379 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44380 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44381 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44382 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44383 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44384 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44385 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44386 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44387 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44388 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44389 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44390 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44391 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44392 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44393 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44394 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44395 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44396 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44397 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
44398 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
44399 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
44400 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
44401 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
44402 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
44403 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44404 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44405 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44406 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44407 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
44408 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
44409 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
44410 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44411 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44412 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44413 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44414 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44415 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44416 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44417 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44418 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44419 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44420 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
44421 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
44422 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
44423 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
44424 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44425 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
44426 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
44427 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44428 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44429 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44430 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44431 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
44432 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
44433 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44434 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44435 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
44436 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44437 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44438 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
44439 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
44440 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44441 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44442 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44443 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44444 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44445 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44446 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44447 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44448 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
44449 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44450 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44451 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
44452 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
44453 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
44454 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
44455 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
44456 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
44457 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
44458 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
44459 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
44460 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
44461 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
44462 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44463 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
44464 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
44465 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
44466 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
44467 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
44468 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
44469 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
44470 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44471 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44472 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
44473 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44474 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44475 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44476 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
44477 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
44478 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
44479 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44480 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44481 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44482 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44483 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44484 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44485 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
44486 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44487 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44488 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44489 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
44490 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
44491 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44492 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44493 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
44494 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
44495 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44496 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44497 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44498 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44499 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
44500 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
44501 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
44502 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
44503 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44504 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44505 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44506 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
44507 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44508 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44509 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44510 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44511 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44512 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
44513 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
44514 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44515 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
44516 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44517 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44518 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44519 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44520 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44521 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44522 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
44523 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44524 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44525 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
44526 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44527 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44528 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44529 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44530 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
44531 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44532 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
44533 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44534 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44535 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44536 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
44537 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44538 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44539 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
44540 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
44541 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
44542 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
44543 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44544 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
44545 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44546 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44547 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44548 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
44549 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
44550 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
44551 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
44552 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
44553 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44554 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44555 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44556 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44557 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44558 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44559 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
44560 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44561 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
44562 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44563 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
44564 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
44565 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44566 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44567 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44568 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44569 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44570 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
44571 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
44572 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44573 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44574 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44575 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
44576 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
44577 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
44578 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
44579 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
44580 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44581 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44582 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
44583 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
44584 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44585 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44586 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
44587 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
44588 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44589 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44590 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
44591 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
44592 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
44593 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
44594 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
44595 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
44596 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
44597 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
44598 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
44599 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
44600 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
44601 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
44602 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
44603 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44604 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44605 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44606 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44607 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
44608 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44609 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44610 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
44611 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44612 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
44613 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44614 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
44615 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44616 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
44617 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44618 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
44619 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44620 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
44621 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44622 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
44623 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44624 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
44625 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44626 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
44627 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44628 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
44629 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44630 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
44631 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44632 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
44633 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
44634 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
44635 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44636 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44637 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44638 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44639 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44640 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44641 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44642 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44643 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44644 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44645 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
44646 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
44647 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44648 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
44649 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44650 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
44651 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44652 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44653 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
44654 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
44655 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
44656 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
44657 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44658 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44659 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44660 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
44661 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
44662 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
44663 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
44664 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
44665 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44666 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
44667 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
44668 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
44669 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
44670 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
44671 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
44672 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
44673 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44674 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44675 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
44676 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
44677 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44678 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44679 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
44680 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
44681 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
44682 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
44683 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44684 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
44685 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44686 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
44687 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
44688 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
44689 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
44690 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44691 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44692 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44693 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44694 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44695 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
44696 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44697 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44698 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44699 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44700 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44701 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
44702 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44703 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
44704 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
44705 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44706 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
44707 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
44708 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44709 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
44710 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
44711 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
44712 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
44713 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44714 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
44715 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44716 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
44717 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
44718 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
44719 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
44720 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
44721 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44722 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44723 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44724 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44725 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44726 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44727 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
44728 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
44729 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
44730 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
44731 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44732 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44733 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44734 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44735 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44736 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
44737 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
44738 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
44739 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
44740 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44741 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44742 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44743 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44744 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44745 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44746 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44747 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44748 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44749 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44750 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44751 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44752 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44753 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44754 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44755 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44756 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44757 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44758 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
44759 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
44760 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
44761 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
44762 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
44763 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
44764 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
44765 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44766 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44767 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44768 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44769 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44770 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44771 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
44772 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44773 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
44774 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
44775 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
44776 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44777 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
44778 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
44779 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44780 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44781 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44782 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44783 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44784 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44785 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44786 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44787 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44788 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44789 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44790 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44791 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44792 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44793 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44794 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44795 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44796 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44797 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44798 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44799 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44800 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44801 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44802 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44803 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44804 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44805 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
44806 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
44807 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
44808 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44809 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44810 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44811 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44812 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44813 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
44814 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
44815 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
44816 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
44817 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
44818 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44819 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44820 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44821 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44822 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44823 { (char *)"MoveEvent_m_pos_set", (PyCFunction) _wrap_MoveEvent_m_pos_set, METH_VARARGS | METH_KEYWORDS, NULL},
44824 { (char *)"MoveEvent_m_pos_get", (PyCFunction) _wrap_MoveEvent_m_pos_get, METH_VARARGS | METH_KEYWORDS, NULL},
44825 { (char *)"MoveEvent_m_rect_set", (PyCFunction) _wrap_MoveEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
44826 { (char *)"MoveEvent_m_rect_get", (PyCFunction) _wrap_MoveEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
44827 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
44828 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44829 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
44830 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44831 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
44832 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44833 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
44834 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
44835 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44836 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44837 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44838 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
44839 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44840 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44841 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
44842 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44843 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44844 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
44845 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44846 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
44847 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44848 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
44849 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
44850 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44851 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
44852 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44853 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
44854 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
44855 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
44856 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44857 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44858 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44859 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
44860 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44861 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
44862 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
44863 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
44864 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44865 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
44866 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
44867 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44868 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
44869 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44870 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
44871 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
44872 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
44873 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44874 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44875 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44876 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
44877 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
44878 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44879 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44880 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44881 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44882 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
44883 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
44884 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
44885 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
44886 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
44887 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44888 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44889 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
44890 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44891 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
44892 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44893 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44894 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
44895 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44896 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
44897 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44898 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44899 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44900 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
44901 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44902 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
44903 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
44904 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
44905 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44906 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44907 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44908 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
44909 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
44910 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44911 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44912 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44913 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
44914 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44915 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44916 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
44917 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44918 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44919 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
44920 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44921 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44922 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44923 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
44924 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44925 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
44926 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
44927 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44928 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44929 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
44930 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
44931 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44932 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44933 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44934 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44935 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
44936 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44937 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44938 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44939 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44940 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
44941 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
44942 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
44943 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44944 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
44945 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
44946 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44947 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44948 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
44949 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
44950 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
44951 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44952 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
44953 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44954 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
44955 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44956 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44957 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44958 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
44959 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
44960 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44961 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44962 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
44963 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44964 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44965 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
44966 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
44967 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
44968 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
44969 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
44970 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
44971 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
44972 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
44973 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
44974 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44975 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44976 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44977 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
44978 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
44979 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44980 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44981 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44982 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
44983 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
44984 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
44985 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
44986 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44987 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
44988 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
44989 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
44990 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44991 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44992 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
44993 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
44994 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
44995 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
44996 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44997 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44998 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
44999 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45000 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45001 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45002 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45003 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45004 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45005 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45006 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45007 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45008 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45009 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45010 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45011 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45012 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
45013 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45014 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45015 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45016 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
45017 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
45018 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45019 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45020 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
45021 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
45022 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45023 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45024 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45025 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45026 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
45027 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
45028 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45029 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45030 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
45031 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45032 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45033 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
45034 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45035 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45036 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45037 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45038 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45039 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45040 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45041 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45042 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45043 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45044 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45045 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45046 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45047 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45048 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
45049 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45050 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45051 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
45052 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
45053 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45054 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
45055 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
45056 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45057 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45058 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45059 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45060 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45061 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45062 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45063 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45064 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45065 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45066 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
45067 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45068 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45069 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45070 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45071 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45072 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45073 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
45074 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45075 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
45076 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45077 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45078 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45079 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45080 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45081 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45082 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45083 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45084 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45085 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45086 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45087 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45088 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45089 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45090 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45091 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45092 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45093 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45094 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45095 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45096 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
45097 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45098 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
45099 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45100 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45101 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45102 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45103 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45104 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
45105 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45106 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45107 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
45108 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45109 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45110 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45111 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
45112 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45113 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45114 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
45115 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45116 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45117 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45118 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
45119 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45120 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45121 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45122 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45123 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
45124 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
45125 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
45126 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
45127 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
45128 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45129 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45130 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45131 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45132 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45133 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45134 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45135 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45136 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45137 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45138 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45139 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45140 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45141 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45142 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45143 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45144 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45145 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45146 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45147 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
45148 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
45149 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45150 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45151 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
45152 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45153 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45154 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45155 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45156 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
45157 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
45158 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
45159 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45160 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
45161 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
45162 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
45163 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
45164 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45165 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
45166 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45167 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
45168 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45169 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45170 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45171 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45172 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45173 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45174 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45175 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45176 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45177 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45178 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45179 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45180 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45181 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
45182 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45183 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45184 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45185 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45186 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45187 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45188 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45189 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
45190 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
45191 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45192 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
45193 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
45194 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
45195 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
45196 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
45197 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
45198 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45199 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45200 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45201 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45202 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
45203 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45204 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45205 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45206 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45207 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
45208 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
45209 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45210 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
45211 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
45212 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
45213 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
45214 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
45215 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
45216 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45217 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
45218 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45219 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
45220 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45221 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45222 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45223 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45224 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45225 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45226 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45227 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45228 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45229 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45230 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45231 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
45232 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45233 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45234 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45235 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45236 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
45237 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
45238 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45239 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45240 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45241 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
45242 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
45243 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45244 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45245 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45247 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45248 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45249 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
45250 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
45252 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45254 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
45255 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
45256 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45258 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45259 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45261 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45264 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45267 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45269 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45274 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
45277 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
45279 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45280 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
45281 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
45282 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
45283 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
45284 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45287 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
45310 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
45337 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
45381 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
45389 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
45406 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
45407 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
45444 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
45474 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
45477 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
45481 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
45484 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
45494 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
45506 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"StdDialogButtonSizer_Finalise", (PyCFunction) _wrap_StdDialogButtonSizer_Finalise, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
45515 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
45525 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
45535 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
45549 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
45556 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
45557 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
45558 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
45559 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
45560 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
45565 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
45592 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
45604 { NULL, NULL, 0, NULL }
45605 };
45606
45607
45608 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
45609
45610 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
45611 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
45612 }
45613 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
45614 return (void *)((wxSizer *) ((wxBoxSizer *) x));
45615 }
45616 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
45617 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
45618 }
45619 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
45620 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45621 }
45622 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
45623 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
45624 }
45625 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
45626 return (void *)((wxSizer *) ((wxGridSizer *) x));
45627 }
45628 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
45629 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
45630 }
45631 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
45632 return (void *)((wxSizer *) ((wxPySizer *) x));
45633 }
45634 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
45635 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
45636 }
45637 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
45638 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45639 }
45640 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
45641 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
45642 }
45643 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
45644 return (void *)((wxEvent *) ((wxMenuEvent *) x));
45645 }
45646 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
45647 return (void *)((wxEvent *) ((wxCloseEvent *) x));
45648 }
45649 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
45650 return (void *)((wxEvent *) ((wxMouseEvent *) x));
45651 }
45652 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
45653 return (void *)((wxEvent *) ((wxEraseEvent *) x));
45654 }
45655 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
45656 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
45657 }
45658 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
45659 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
45660 }
45661 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
45662 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
45663 }
45664 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
45665 return (void *)((wxEvent *) ((wxPyEvent *) x));
45666 }
45667 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
45668 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
45669 }
45670 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
45671 return (void *)((wxEvent *) ((wxIdleEvent *) x));
45672 }
45673 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
45674 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
45675 }
45676 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
45677 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
45678 }
45679 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
45680 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
45681 }
45682 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
45683 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
45684 }
45685 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
45686 return (void *)((wxEvent *) ((wxActivateEvent *) x));
45687 }
45688 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
45689 return (void *)((wxEvent *) ((wxSizeEvent *) x));
45690 }
45691 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
45692 return (void *)((wxEvent *) ((wxMoveEvent *) x));
45693 }
45694 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
45695 return (void *)((wxEvent *) ((wxPaintEvent *) x));
45696 }
45697 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
45698 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
45699 }
45700 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
45701 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
45702 }
45703 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
45704 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
45705 }
45706 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
45707 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
45708 }
45709 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
45710 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
45711 }
45712 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
45713 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
45714 }
45715 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
45716 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
45717 }
45718 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
45719 return (void *)((wxEvent *) ((wxFocusEvent *) x));
45720 }
45721 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
45722 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
45723 }
45724 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
45725 return (void *)((wxEvent *) ((wxShowEvent *) x));
45726 }
45727 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
45728 return (void *)((wxEvent *) ((wxCommandEvent *) x));
45729 }
45730 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
45731 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
45732 }
45733 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
45734 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45735 }
45736 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
45737 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
45738 }
45739 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
45740 return (void *)((wxEvent *) ((wxKeyEvent *) x));
45741 }
45742 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
45743 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
45744 }
45745 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
45746 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
45747 }
45748 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
45749 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
45750 }
45751 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
45752 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
45753 }
45754 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
45755 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
45756 }
45757 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
45758 return (void *)((wxControl *) ((wxControlWithItems *) x));
45759 }
45760 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
45761 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
45762 }
45763 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
45764 return (void *)((wxEvtHandler *) ((wxWindow *) x));
45765 }
45766 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
45767 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
45768 }
45769 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
45770 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
45771 }
45772 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
45773 return (void *)((wxEvtHandler *) ((wxValidator *) x));
45774 }
45775 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
45776 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
45777 }
45778 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
45779 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
45780 }
45781 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
45782 return (void *)((wxEvtHandler *) ((wxMenu *) x));
45783 }
45784 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
45785 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
45786 }
45787 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
45788 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
45789 }
45790 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
45791 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
45792 }
45793 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
45794 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
45795 }
45796 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
45797 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
45798 }
45799 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
45800 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45801 }
45802 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
45803 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
45804 }
45805 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
45806 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
45807 }
45808 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
45809 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
45810 }
45811 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
45812 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45813 }
45814 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
45815 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
45816 }
45817 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
45818 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
45819 }
45820 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
45821 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
45822 }
45823 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
45824 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
45825 }
45826 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
45827 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
45828 }
45829 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
45830 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
45831 }
45832 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
45833 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
45834 }
45835 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
45836 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
45837 }
45838 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
45839 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
45840 }
45841 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
45842 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
45843 }
45844 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
45845 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
45846 }
45847 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
45848 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
45849 }
45850 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
45851 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
45852 }
45853 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
45854 return (void *)((wxObject *) ((wxSizerItem *) x));
45855 }
45856 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
45857 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
45858 }
45859 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
45860 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
45861 }
45862 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
45863 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
45864 }
45865 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
45866 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
45867 }
45868 static void *_p_wxSizerTo_p_wxObject(void *x) {
45869 return (void *)((wxObject *) ((wxSizer *) x));
45870 }
45871 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
45872 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
45873 }
45874 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
45875 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
45876 }
45877 static void *_p_wxEventTo_p_wxObject(void *x) {
45878 return (void *)((wxObject *) ((wxEvent *) x));
45879 }
45880 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
45881 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
45882 }
45883 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
45884 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
45885 }
45886 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
45887 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
45888 }
45889 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
45890 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
45891 }
45892 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
45893 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
45894 }
45895 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
45896 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
45897 }
45898 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
45899 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
45900 }
45901 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
45902 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
45903 }
45904 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
45905 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
45906 }
45907 static void *_p_wxControlTo_p_wxObject(void *x) {
45908 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
45909 }
45910 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
45911 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
45912 }
45913 static void *_p_wxFSFileTo_p_wxObject(void *x) {
45914 return (void *)((wxObject *) ((wxFSFile *) x));
45915 }
45916 static void *_p_wxPySizerTo_p_wxObject(void *x) {
45917 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
45918 }
45919 static void *_p_wxPyEventTo_p_wxObject(void *x) {
45920 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
45921 }
45922 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
45923 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
45924 }
45925 static void *_p_wxShowEventTo_p_wxObject(void *x) {
45926 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
45927 }
45928 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
45929 return (void *)((wxObject *) ((wxMenuItem *) x));
45930 }
45931 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
45932 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
45933 }
45934 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
45935 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
45936 }
45937 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
45938 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
45939 }
45940 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
45941 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
45942 }
45943 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
45944 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
45945 }
45946 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
45947 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
45948 }
45949 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
45950 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
45951 }
45952 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
45953 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
45954 }
45955 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
45956 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
45957 }
45958 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
45959 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
45960 }
45961 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
45962 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
45963 }
45964 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
45965 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
45966 }
45967 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
45968 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
45969 }
45970 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
45971 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
45972 }
45973 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
45974 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45975 }
45976 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
45977 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
45978 }
45979 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
45980 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
45981 }
45982 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
45983 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
45984 }
45985 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
45986 return (void *)((wxObject *) ((wxImageHandler *) x));
45987 }
45988 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
45989 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
45990 }
45991 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
45992 return (void *)((wxObject *) ((wxEvtHandler *) x));
45993 }
45994 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
45995 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45996 }
45997 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
45998 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
45999 }
46000 static void *_p_wxImageTo_p_wxObject(void *x) {
46001 return (void *)((wxObject *) ((wxImage *) x));
46002 }
46003 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
46004 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
46005 }
46006 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
46007 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46008 }
46009 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
46010 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
46011 }
46012 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
46013 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
46014 }
46015 static void *_p_wxWindowTo_p_wxObject(void *x) {
46016 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
46017 }
46018 static void *_p_wxMenuTo_p_wxObject(void *x) {
46019 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
46020 }
46021 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
46022 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
46023 }
46024 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
46025 return (void *)((wxObject *) ((wxFileSystem *) x));
46026 }
46027 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
46028 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
46029 }
46030 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
46031 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
46032 }
46033 static void *_p_wxPyAppTo_p_wxObject(void *x) {
46034 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
46035 }
46036 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
46037 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
46038 }
46039 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
46040 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
46041 }
46042 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
46043 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
46044 }
46045 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
46046 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
46047 }
46048 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
46049 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
46050 }
46051 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
46052 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
46053 }
46054 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
46055 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
46056 }
46057 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
46058 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
46059 }
46060 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
46061 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46062 }
46063 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
46064 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
46065 }
46066 static void *_p_wxValidatorTo_p_wxObject(void *x) {
46067 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
46068 }
46069 static void *_p_wxControlTo_p_wxWindow(void *x) {
46070 return (void *)((wxWindow *) ((wxControl *) x));
46071 }
46072 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
46073 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
46074 }
46075 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
46076 return (void *)((wxWindow *) ((wxMenuBar *) x));
46077 }
46078 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
46079 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
46080 }
46081 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
46082 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
46083 }
46084 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
46085 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
46086 }
46087 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
46088 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
46089 }
46090 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
46091 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46092 }
46093 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
46094 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
46095 }
46096 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
46097 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
46098 }
46099 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
46100 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
46101 }
46102 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
46103 return (void *)((wxValidator *) ((wxPyValidator *) x));
46104 }
46105 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}};
46106 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}};
46107 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}};
46108 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}};
46109 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}};
46110 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}};
46111 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}};
46112 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}};
46113 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}};
46114 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}};
46115 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}};
46116 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}};
46117 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}};
46118 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46119 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}};
46120 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}};
46121 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}};
46122 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}};
46123 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}};
46124 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}};
46125 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}};
46126 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}};
46127 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}};
46128 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}};
46129 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}};
46130 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}};
46131 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}};
46132 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}};
46133 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}};
46134 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}};
46135 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}};
46136 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}};
46137 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}};
46138 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}};
46139 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}};
46140 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}};
46141 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}};
46142 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}};
46143 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}};
46144 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}};
46145 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}};
46146 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}};
46147 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}};
46148 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}};
46149 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}};
46150 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}};
46151 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}};
46152 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}};
46153 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}};
46154 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}};
46155 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}};
46156 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}};
46157 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}};
46158 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}};
46159 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}};
46160 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}};
46161 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}};
46162 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}};
46163 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}};
46164 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}};
46165 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}};
46166 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}};
46167 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}};
46168 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}};
46169 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}};
46170 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}};
46171 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}};
46172 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}};
46173 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}};
46174 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}};
46175 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}};
46176 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}};
46177 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}};
46178 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}};
46179 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}};
46180 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}};
46181 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}};
46182 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}};
46183 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}};
46184 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}};
46185 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}};
46186 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}};
46187 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}};
46188 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}};
46189 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}};
46190 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}};
46191 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}};
46192 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}};
46193 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}};
46194 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}};
46195 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}};
46196 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}};
46197 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}};
46198 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46199 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}};
46200 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}};
46201 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}};
46202 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}};
46203 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}};
46204 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}};
46205 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}};
46206 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}};
46207 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}};
46208 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}};
46209 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}};
46210 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}};
46211 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}};
46212 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}};
46213 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}};
46214 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}};
46215 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *|byte *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46216 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}};
46217 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}};
46218 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}};
46219 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}};
46220 static swig_type_info _swigt__p_wxCommandEvent[] = {{"_p_wxCommandEvent", 0, "wxCommandEvent *", 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", 0, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46221 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}};
46222 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}};
46223 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}};
46224 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}};
46225 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}};
46226 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}};
46227 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}};
46228 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}};
46229 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}};
46230 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}};
46231
46232 static swig_type_info *swig_types_initial[] = {
46233 _swigt__p_wxLayoutConstraints,
46234 _swigt__p_wxRealPoint,
46235 _swigt__p_wxSizerItem,
46236 _swigt__p_wxGBSizerItem,
46237 _swigt__p_wxScrollEvent,
46238 _swigt__p_wxEventLoop,
46239 _swigt__p_wxIndividualLayoutConstraint,
46240 _swigt__p_wxSizer,
46241 _swigt__p_wxBoxSizer,
46242 _swigt__p_wxStaticBoxSizer,
46243 _swigt__p_wxGridBagSizer,
46244 _swigt__p_wxAcceleratorEntry,
46245 _swigt__p_wxUpdateUIEvent,
46246 _swigt__p_wxEvent,
46247 _swigt__p_wxMenu,
46248 _swigt__p_wxGridSizer,
46249 _swigt__p_wxFlexGridSizer,
46250 _swigt__p_wxInitDialogEvent,
46251 _swigt__p_wxItemContainer,
46252 _swigt__p_wxNcPaintEvent,
46253 _swigt__p_wxPaintEvent,
46254 _swigt__p_wxSysColourChangedEvent,
46255 _swigt__p_wxMouseCaptureChangedEvent,
46256 _swigt__p_wxDisplayChangedEvent,
46257 _swigt__p_wxPaletteChangedEvent,
46258 _swigt__p_wxControl,
46259 _swigt__p_wxFont,
46260 _swigt__p_wxMenuBarBase,
46261 _swigt__p_wxSetCursorEvent,
46262 _swigt__p_wxFSFile,
46263 _swigt__p_wxCaret,
46264 _swigt__ptrdiff_t,
46265 _swigt__std__ptrdiff_t,
46266 _swigt__p_wxRegion,
46267 _swigt__p_wxPoint2D,
46268 _swigt__p_int,
46269 _swigt__p_wxSize,
46270 _swigt__p_wxDC,
46271 _swigt__p_wxPySizer,
46272 _swigt__p_wxVisualAttributes,
46273 _swigt__p_wxNotifyEvent,
46274 _swigt__p_wxPyEvent,
46275 _swigt__p_wxPropagationDisabler,
46276 _swigt__p_form_ops_t,
46277 _swigt__p_wxAppTraits,
46278 _swigt__p_wxArrayString,
46279 _swigt__p_wxShowEvent,
46280 _swigt__p_wxToolTip,
46281 _swigt__p_wxMoveEvent,
46282 _swigt__p_wxSizeEvent,
46283 _swigt__p_wxActivateEvent,
46284 _swigt__p_wxIconizeEvent,
46285 _swigt__p_wxMaximizeEvent,
46286 _swigt__p_wxQueryNewPaletteEvent,
46287 _swigt__p_wxWindowCreateEvent,
46288 _swigt__p_wxIdleEvent,
46289 _swigt__p_wxMenuItem,
46290 _swigt__p_wxStaticBox,
46291 _swigt__p_long,
46292 _swigt__p_wxDuplexMode,
46293 _swigt__p_wxTIFFHandler,
46294 _swigt__p_wxXPMHandler,
46295 _swigt__p_wxPNMHandler,
46296 _swigt__p_wxJPEGHandler,
46297 _swigt__p_wxPCXHandler,
46298 _swigt__p_wxGIFHandler,
46299 _swigt__p_wxPNGHandler,
46300 _swigt__p_wxANIHandler,
46301 _swigt__p_wxMemoryFSHandler,
46302 _swigt__p_wxZipFSHandler,
46303 _swigt__p_wxInternetFSHandler,
46304 _swigt__p_wxPyFileSystemHandler,
46305 _swigt__p_wxEvtHandler,
46306 _swigt__p_wxCURHandler,
46307 _swigt__p_wxICOHandler,
46308 _swigt__p_wxBMPHandler,
46309 _swigt__p_wxImageHandler,
46310 _swigt__p_wxFileSystemHandler,
46311 _swigt__p_wxRect,
46312 _swigt__p_wxButton,
46313 _swigt__p_wxGBSpan,
46314 _swigt__p_wxPropagateOnce,
46315 _swigt__p_wxAcceleratorTable,
46316 _swigt__p_wxStdDialogButtonSizer,
46317 _swigt__p_char,
46318 _swigt__p_wxGBPosition,
46319 _swigt__p_wxImage,
46320 _swigt__p_wxFrame,
46321 _swigt__p_wxScrollWinEvent,
46322 _swigt__p_wxPaperSize,
46323 _swigt__p_wxImageHistogram,
46324 _swigt__p_wxPoint,
46325 _swigt__p_wxCursor,
46326 _swigt__p_wxObject,
46327 _swigt__p_wxInputStream,
46328 _swigt__p_wxOutputStream,
46329 _swigt__p_wxPyInputStream,
46330 _swigt__p_wxDateTime,
46331 _swigt__p_wxKeyEvent,
46332 _swigt__p_wxNavigationKeyEvent,
46333 _swigt__p_wxWindowDestroyEvent,
46334 _swigt__p_unsigned_long,
46335 _swigt__p_wxWindow,
46336 _swigt__p_wxMenuBar,
46337 _swigt__p_wxFileSystem,
46338 _swigt__p_wxBitmap,
46339 _swigt__unsigned_int,
46340 _swigt__p_unsigned_int,
46341 _swigt__p_wxMenuEvent,
46342 _swigt__p_wxContextMenuEvent,
46343 _swigt__p_unsigned_char,
46344 _swigt__p_wxEraseEvent,
46345 _swigt__p_wxMouseEvent,
46346 _swigt__p_wxCloseEvent,
46347 _swigt__p_wxPyApp,
46348 _swigt__p_wxCommandEvent,
46349 _swigt__p_wxPyCommandEvent,
46350 _swigt__p_wxPyDropTarget,
46351 _swigt__p_wxQuantize,
46352 _swigt__p_wxChildFocusEvent,
46353 _swigt__p_wxFocusEvent,
46354 _swigt__p_wxDropFilesEvent,
46355 _swigt__p_wxControlWithItems,
46356 _swigt__p_wxColour,
46357 _swigt__p_wxValidator,
46358 _swigt__p_wxPyValidator,
46359 0
46360 };
46361
46362
46363 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
46364
46365 static swig_const_info swig_const_table[] = {
46366 {0, 0, 0, 0.0, 0, 0}};
46367
46368 #ifdef __cplusplus
46369 }
46370 #endif
46371
46372
46373 #ifdef __cplusplus
46374 extern "C" {
46375 #endif
46376
46377 /* Python-specific SWIG API */
46378 #define SWIG_newvarlink() SWIG_Python_newvarlink()
46379 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
46380 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
46381
46382 /* -----------------------------------------------------------------------------
46383 * global variable support code.
46384 * ----------------------------------------------------------------------------- */
46385
46386 typedef struct swig_globalvar {
46387 char *name; /* Name of global variable */
46388 PyObject *(*get_attr)(); /* Return the current value */
46389 int (*set_attr)(PyObject *); /* Set the value */
46390 struct swig_globalvar *next;
46391 } swig_globalvar;
46392
46393 typedef struct swig_varlinkobject {
46394 PyObject_HEAD
46395 swig_globalvar *vars;
46396 } swig_varlinkobject;
46397
46398 static PyObject *
46399 swig_varlink_repr(swig_varlinkobject *v) {
46400 v = v;
46401 return PyString_FromString("<Swig global variables>");
46402 }
46403
46404 static int
46405 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
46406 swig_globalvar *var;
46407 flags = flags;
46408 fprintf(fp,"Swig global variables { ");
46409 for (var = v->vars; var; var=var->next) {
46410 fprintf(fp,"%s", var->name);
46411 if (var->next) fprintf(fp,", ");
46412 }
46413 fprintf(fp," }\n");
46414 return 0;
46415 }
46416
46417 static PyObject *
46418 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
46419 swig_globalvar *var = v->vars;
46420 while (var) {
46421 if (strcmp(var->name,n) == 0) {
46422 return (*var->get_attr)();
46423 }
46424 var = var->next;
46425 }
46426 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46427 return NULL;
46428 }
46429
46430 static int
46431 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
46432 swig_globalvar *var = v->vars;
46433 while (var) {
46434 if (strcmp(var->name,n) == 0) {
46435 return (*var->set_attr)(p);
46436 }
46437 var = var->next;
46438 }
46439 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46440 return 1;
46441 }
46442
46443 static PyTypeObject varlinktype = {
46444 PyObject_HEAD_INIT(0)
46445 0, /* Number of items in variable part (ob_size) */
46446 (char *)"swigvarlink", /* Type name (tp_name) */
46447 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
46448 0, /* Itemsize (tp_itemsize) */
46449 0, /* Deallocator (tp_dealloc) */
46450 (printfunc) swig_varlink_print, /* Print (tp_print) */
46451 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
46452 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
46453 0, /* tp_compare */
46454 (reprfunc) swig_varlink_repr, /* tp_repr */
46455 0, /* tp_as_number */
46456 0, /* tp_as_sequence */
46457 0, /* tp_as_mapping */
46458 0, /* tp_hash */
46459 0, /* tp_call */
46460 0, /* tp_str */
46461 0, /* tp_getattro */
46462 0, /* tp_setattro */
46463 0, /* tp_as_buffer */
46464 0, /* tp_flags */
46465 0, /* tp_doc */
46466 #if PY_VERSION_HEX >= 0x02000000
46467 0, /* tp_traverse */
46468 0, /* tp_clear */
46469 #endif
46470 #if PY_VERSION_HEX >= 0x02010000
46471 0, /* tp_richcompare */
46472 0, /* tp_weaklistoffset */
46473 #endif
46474 #if PY_VERSION_HEX >= 0x02020000
46475 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
46476 #endif
46477 #if PY_VERSION_HEX >= 0x02030000
46478 0, /* tp_del */
46479 #endif
46480 #ifdef COUNT_ALLOCS
46481 0,0,0,0 /* tp_alloc -> tp_next */
46482 #endif
46483 };
46484
46485 /* Create a variable linking object for use later */
46486 static PyObject *
46487 SWIG_Python_newvarlink(void) {
46488 swig_varlinkobject *result = 0;
46489 result = PyMem_NEW(swig_varlinkobject,1);
46490 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
46491 result->ob_type = &varlinktype;
46492 result->vars = 0;
46493 result->ob_refcnt = 0;
46494 Py_XINCREF((PyObject *) result);
46495 return ((PyObject*) result);
46496 }
46497
46498 static void
46499 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
46500 swig_varlinkobject *v;
46501 swig_globalvar *gv;
46502 v= (swig_varlinkobject *) p;
46503 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
46504 gv->name = (char *) malloc(strlen(name)+1);
46505 strcpy(gv->name,name);
46506 gv->get_attr = get_attr;
46507 gv->set_attr = set_attr;
46508 gv->next = v->vars;
46509 v->vars = gv;
46510 }
46511
46512 /* -----------------------------------------------------------------------------
46513 * constants/methods manipulation
46514 * ----------------------------------------------------------------------------- */
46515
46516 /* Install Constants */
46517 static void
46518 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
46519 PyObject *obj = 0;
46520 size_t i;
46521 for (i = 0; constants[i].type; i++) {
46522 switch(constants[i].type) {
46523 case SWIG_PY_INT:
46524 obj = PyInt_FromLong(constants[i].lvalue);
46525 break;
46526 case SWIG_PY_FLOAT:
46527 obj = PyFloat_FromDouble(constants[i].dvalue);
46528 break;
46529 case SWIG_PY_STRING:
46530 if (constants[i].pvalue) {
46531 obj = PyString_FromString((char *) constants[i].pvalue);
46532 } else {
46533 Py_INCREF(Py_None);
46534 obj = Py_None;
46535 }
46536 break;
46537 case SWIG_PY_POINTER:
46538 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
46539 break;
46540 case SWIG_PY_BINARY:
46541 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
46542 break;
46543 default:
46544 obj = 0;
46545 break;
46546 }
46547 if (obj) {
46548 PyDict_SetItemString(d,constants[i].name,obj);
46549 Py_DECREF(obj);
46550 }
46551 }
46552 }
46553
46554 /* -----------------------------------------------------------------------------*/
46555 /* Fix SwigMethods to carry the callback ptrs when needed */
46556 /* -----------------------------------------------------------------------------*/
46557
46558 static void
46559 SWIG_Python_FixMethods(PyMethodDef *methods,
46560 swig_const_info *const_table,
46561 swig_type_info **types,
46562 swig_type_info **types_initial) {
46563 size_t i;
46564 for (i = 0; methods[i].ml_name; ++i) {
46565 char *c = methods[i].ml_doc;
46566 if (c && (c = strstr(c, "swig_ptr: "))) {
46567 int j;
46568 swig_const_info *ci = 0;
46569 char *name = c + 10;
46570 for (j = 0; const_table[j].type; j++) {
46571 if (strncmp(const_table[j].name, name,
46572 strlen(const_table[j].name)) == 0) {
46573 ci = &(const_table[j]);
46574 break;
46575 }
46576 }
46577 if (ci) {
46578 size_t shift = (ci->ptype) - types;
46579 swig_type_info *ty = types_initial[shift];
46580 size_t ldoc = (c - methods[i].ml_doc);
46581 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
46582 char *ndoc = (char*)malloc(ldoc + lptr + 10);
46583 char *buff = ndoc;
46584 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
46585 strncpy(buff, methods[i].ml_doc, ldoc);
46586 buff += ldoc;
46587 strncpy(buff, "swig_ptr: ", 10);
46588 buff += 10;
46589 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
46590 methods[i].ml_doc = ndoc;
46591 }
46592 }
46593 }
46594 }
46595
46596 /* -----------------------------------------------------------------------------*
46597 * Initialize type list
46598 * -----------------------------------------------------------------------------*/
46599
46600 #if PY_MAJOR_VERSION < 2
46601 /* PyModule_AddObject function was introduced in Python 2.0. The following function
46602 is copied out of Python/modsupport.c in python version 2.3.4 */
46603 static int
46604 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
46605 {
46606 PyObject *dict;
46607 if (!PyModule_Check(m)) {
46608 PyErr_SetString(PyExc_TypeError,
46609 "PyModule_AddObject() needs module as first arg");
46610 return -1;
46611 }
46612 if (!o) {
46613 PyErr_SetString(PyExc_TypeError,
46614 "PyModule_AddObject() needs non-NULL value");
46615 return -1;
46616 }
46617
46618 dict = PyModule_GetDict(m);
46619 if (dict == NULL) {
46620 /* Internal error -- modules must have a dict! */
46621 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
46622 PyModule_GetName(m));
46623 return -1;
46624 }
46625 if (PyDict_SetItemString(dict, name, o))
46626 return -1;
46627 Py_DECREF(o);
46628 return 0;
46629 }
46630 #endif
46631
46632 static swig_type_info **
46633 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
46634 static PyMethodDef swig_empty_runtime_method_table[] = {
46635 {
46636 NULL, NULL, 0, NULL
46637 }
46638 };/* Sentinel */
46639
46640 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
46641 swig_empty_runtime_method_table);
46642 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
46643 if (pointer && module) {
46644 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
46645 }
46646 return type_list_handle;
46647 }
46648
46649 static swig_type_info **
46650 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
46651 swig_type_info **type_pointer;
46652
46653 /* first check if module already created */
46654 type_pointer = SWIG_Python_GetTypeListHandle();
46655 if (type_pointer) {
46656 return type_pointer;
46657 } else {
46658 /* create a new module and variable */
46659 return SWIG_Python_SetTypeListHandle(type_list_handle);
46660 }
46661 }
46662
46663 #ifdef __cplusplus
46664 }
46665 #endif
46666
46667 /* -----------------------------------------------------------------------------*
46668 * Partial Init method
46669 * -----------------------------------------------------------------------------*/
46670
46671 #ifdef SWIG_LINK_RUNTIME
46672 #ifdef __cplusplus
46673 extern "C"
46674 #endif
46675 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
46676 #endif
46677
46678 #ifdef __cplusplus
46679 extern "C"
46680 #endif
46681 SWIGEXPORT(void) SWIG_init(void) {
46682 static PyObject *SWIG_globals = 0;
46683 static int typeinit = 0;
46684 PyObject *m, *d;
46685 int i;
46686 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
46687
46688 /* Fix SwigMethods to carry the callback ptrs when needed */
46689 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
46690
46691 m = Py_InitModule((char *) SWIG_name, SwigMethods);
46692 d = PyModule_GetDict(m);
46693
46694 if (!typeinit) {
46695 #ifdef SWIG_LINK_RUNTIME
46696 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
46697 #else
46698 # ifndef SWIG_STATIC_RUNTIME
46699 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
46700 # endif
46701 #endif
46702 for (i = 0; swig_types_initial[i]; i++) {
46703 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
46704 }
46705 typeinit = 1;
46706 }
46707 SWIG_InstallConstants(d,swig_const_table);
46708
46709
46710 #ifndef wxPyUSE_EXPORT
46711 // Make our API structure a CObject so other modules can import it
46712 // from this module.
46713 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
46714 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
46715 Py_XDECREF(cobj);
46716 #endif
46717
46718 {
46719 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
46720 }
46721 {
46722 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
46723 }
46724 {
46725 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
46726 }
46727 {
46728 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
46729 }
46730 {
46731 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
46732 }
46733 {
46734 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
46735 }
46736 {
46737 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
46738 }
46739 {
46740 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
46741 }
46742 {
46743 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
46744 }
46745 {
46746 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
46747 }
46748 {
46749 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
46750 }
46751 {
46752 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
46753 }
46754 {
46755 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
46756 }
46757 {
46758 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
46759 }
46760 {
46761 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
46762 }
46763 {
46764 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
46765 }
46766 {
46767 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
46768 }
46769 {
46770 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
46771 }
46772 {
46773 PyDict_SetItemString(d,"ED_CLIENT_MARGIN", SWIG_From_int((int)(wxED_CLIENT_MARGIN)));
46774 }
46775 {
46776 PyDict_SetItemString(d,"ED_BUTTONS_BOTTOM", SWIG_From_int((int)(wxED_BUTTONS_BOTTOM)));
46777 }
46778 {
46779 PyDict_SetItemString(d,"ED_BUTTONS_RIGHT", SWIG_From_int((int)(wxED_BUTTONS_RIGHT)));
46780 }
46781 {
46782 PyDict_SetItemString(d,"ED_STATIC_LINE", SWIG_From_int((int)(wxED_STATIC_LINE)));
46783 }
46784 {
46785 PyDict_SetItemString(d,"EXT_DIALOG_STYLE", SWIG_From_int((int)(wxEXT_DIALOG_STYLE)));
46786 }
46787 {
46788 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
46789 }
46790 {
46791 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
46792 }
46793 {
46794 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
46795 }
46796 {
46797 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
46798 }
46799 {
46800 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
46801 }
46802 {
46803 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
46804 }
46805 {
46806 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
46807 }
46808 {
46809 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
46810 }
46811 {
46812 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
46813 }
46814 {
46815 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
46816 }
46817 {
46818 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
46819 }
46820 {
46821 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
46822 }
46823 {
46824 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
46825 }
46826 {
46827 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
46828 }
46829 {
46830 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
46831 }
46832 {
46833 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
46834 }
46835 {
46836 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
46837 }
46838 {
46839 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
46840 }
46841 {
46842 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
46843 }
46844 {
46845 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
46846 }
46847 {
46848 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
46849 }
46850 {
46851 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
46852 }
46853 {
46854 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
46855 }
46856 {
46857 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
46858 }
46859 {
46860 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
46861 }
46862 {
46863 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
46864 }
46865 {
46866 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
46867 }
46868 {
46869 PyDict_SetItemString(d,"SL_HORIZONTAL", SWIG_From_int((int)(wxSL_HORIZONTAL)));
46870 }
46871 {
46872 PyDict_SetItemString(d,"SL_VERTICAL", SWIG_From_int((int)(wxSL_VERTICAL)));
46873 }
46874 {
46875 PyDict_SetItemString(d,"SL_AUTOTICKS", SWIG_From_int((int)(wxSL_AUTOTICKS)));
46876 }
46877 {
46878 PyDict_SetItemString(d,"SL_LABELS", SWIG_From_int((int)(wxSL_LABELS)));
46879 }
46880 {
46881 PyDict_SetItemString(d,"SL_LEFT", SWIG_From_int((int)(wxSL_LEFT)));
46882 }
46883 {
46884 PyDict_SetItemString(d,"SL_TOP", SWIG_From_int((int)(wxSL_TOP)));
46885 }
46886 {
46887 PyDict_SetItemString(d,"SL_RIGHT", SWIG_From_int((int)(wxSL_RIGHT)));
46888 }
46889 {
46890 PyDict_SetItemString(d,"SL_BOTTOM", SWIG_From_int((int)(wxSL_BOTTOM)));
46891 }
46892 {
46893 PyDict_SetItemString(d,"SL_BOTH", SWIG_From_int((int)(wxSL_BOTH)));
46894 }
46895 {
46896 PyDict_SetItemString(d,"SL_SELRANGE", SWIG_From_int((int)(wxSL_SELRANGE)));
46897 }
46898 {
46899 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
46900 }
46901 {
46902 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
46903 }
46904 {
46905 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
46906 }
46907 {
46908 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
46909 }
46910 {
46911 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
46912 }
46913 {
46914 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
46915 }
46916 {
46917 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
46918 }
46919 {
46920 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
46921 }
46922 {
46923 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
46924 }
46925 {
46926 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
46927 }
46928 {
46929 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
46930 }
46931 {
46932 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
46933 }
46934 {
46935 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
46936 }
46937 {
46938 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
46939 }
46940 {
46941 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
46942 }
46943 {
46944 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
46945 }
46946 {
46947 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
46948 }
46949 {
46950 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
46951 }
46952 {
46953 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
46954 }
46955 {
46956 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
46957 }
46958 {
46959 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
46960 }
46961 {
46962 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
46963 }
46964 {
46965 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
46966 }
46967 {
46968 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
46969 }
46970 {
46971 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
46972 }
46973 {
46974 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
46975 }
46976 {
46977 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
46978 }
46979 {
46980 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
46981 }
46982 {
46983 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
46984 }
46985 {
46986 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
46987 }
46988 {
46989 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
46990 }
46991 {
46992 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
46993 }
46994 {
46995 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
46996 }
46997 {
46998 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
46999 }
47000 {
47001 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47002 }
47003 {
47004 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47005 }
47006 {
47007 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47008 }
47009 {
47010 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47011 }
47012 {
47013 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47014 }
47015 {
47016 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47017 }
47018 {
47019 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47020 }
47021 {
47022 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47023 }
47024 {
47025 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
47026 }
47027 {
47028 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
47029 }
47030 {
47031 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
47032 }
47033 {
47034 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
47035 }
47036 {
47037 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
47038 }
47039 {
47040 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
47041 }
47042 {
47043 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
47044 }
47045 {
47046 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
47047 }
47048 {
47049 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
47050 }
47051 {
47052 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
47053 }
47054 {
47055 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
47056 }
47057 {
47058 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
47059 }
47060 {
47061 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
47062 }
47063 {
47064 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
47065 }
47066 {
47067 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
47068 }
47069 {
47070 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
47071 }
47072 {
47073 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
47074 }
47075 {
47076 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
47077 }
47078 {
47079 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
47080 }
47081 {
47082 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
47083 }
47084 {
47085 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
47086 }
47087 {
47088 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
47089 }
47090 {
47091 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
47092 }
47093 {
47094 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
47095 }
47096 {
47097 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
47098 }
47099 {
47100 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
47101 }
47102 {
47103 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
47104 }
47105 {
47106 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
47107 }
47108 {
47109 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
47110 }
47111 {
47112 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
47113 }
47114 {
47115 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
47116 }
47117 {
47118 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
47119 }
47120 {
47121 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
47122 }
47123 {
47124 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
47125 }
47126 {
47127 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
47128 }
47129 {
47130 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
47131 }
47132 {
47133 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
47134 }
47135 {
47136 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
47137 }
47138 {
47139 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
47140 }
47141 {
47142 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
47143 }
47144 {
47145 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
47146 }
47147 {
47148 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
47149 }
47150 {
47151 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
47152 }
47153 {
47154 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
47155 }
47156 {
47157 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
47158 }
47159 {
47160 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
47161 }
47162 {
47163 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
47164 }
47165 {
47166 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
47167 }
47168 {
47169 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
47170 }
47171 {
47172 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
47173 }
47174 {
47175 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
47176 }
47177 {
47178 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
47179 }
47180 {
47181 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
47182 }
47183 {
47184 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
47185 }
47186 {
47187 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
47188 }
47189 {
47190 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
47191 }
47192 {
47193 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
47194 }
47195 {
47196 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
47197 }
47198 {
47199 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
47200 }
47201 {
47202 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
47203 }
47204 {
47205 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
47206 }
47207 {
47208 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
47209 }
47210 {
47211 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
47212 }
47213 {
47214 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
47215 }
47216 {
47217 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
47218 }
47219 {
47220 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
47221 }
47222 {
47223 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
47224 }
47225 {
47226 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
47227 }
47228 {
47229 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
47230 }
47231 {
47232 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
47233 }
47234 {
47235 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
47236 }
47237 {
47238 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
47239 }
47240 {
47241 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
47242 }
47243 {
47244 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
47245 }
47246 {
47247 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
47248 }
47249 {
47250 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
47251 }
47252 {
47253 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
47254 }
47255 {
47256 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
47257 }
47258 {
47259 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
47260 }
47261 {
47262 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
47263 }
47264 {
47265 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
47266 }
47267 {
47268 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
47269 }
47270 {
47271 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
47272 }
47273 {
47274 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
47275 }
47276 {
47277 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
47278 }
47279 {
47280 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
47281 }
47282 {
47283 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
47284 }
47285 {
47286 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
47287 }
47288 {
47289 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
47290 }
47291 {
47292 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
47293 }
47294 {
47295 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
47296 }
47297 {
47298 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
47299 }
47300 {
47301 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
47302 }
47303 {
47304 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
47305 }
47306 {
47307 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
47308 }
47309 {
47310 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
47311 }
47312 {
47313 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
47314 }
47315 {
47316 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
47317 }
47318 {
47319 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
47320 }
47321 {
47322 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
47323 }
47324 {
47325 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
47326 }
47327 {
47328 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
47329 }
47330 {
47331 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
47332 }
47333 {
47334 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
47335 }
47336 {
47337 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
47338 }
47339 {
47340 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
47341 }
47342 {
47343 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
47344 }
47345 {
47346 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
47347 }
47348 {
47349 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
47350 }
47351 {
47352 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
47353 }
47354 {
47355 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
47356 }
47357 {
47358 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
47359 }
47360 {
47361 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
47362 }
47363 {
47364 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
47365 }
47366 {
47367 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
47368 }
47369 {
47370 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
47371 }
47372 {
47373 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
47374 }
47375 {
47376 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
47377 }
47378 {
47379 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
47380 }
47381 {
47382 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
47383 }
47384 {
47385 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
47386 }
47387 {
47388 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
47389 }
47390 {
47391 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
47392 }
47393 {
47394 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
47395 }
47396 {
47397 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
47398 }
47399 {
47400 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
47401 }
47402 {
47403 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
47404 }
47405 {
47406 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
47407 }
47408 {
47409 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
47410 }
47411 {
47412 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
47413 }
47414 {
47415 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
47416 }
47417 {
47418 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
47419 }
47420 {
47421 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
47422 }
47423 {
47424 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
47425 }
47426 {
47427 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
47428 }
47429 {
47430 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
47431 }
47432 {
47433 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
47434 }
47435 {
47436 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
47437 }
47438 {
47439 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
47440 }
47441 {
47442 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
47443 }
47444 {
47445 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
47446 }
47447 {
47448 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
47449 }
47450 {
47451 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
47452 }
47453 {
47454 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
47455 }
47456 {
47457 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
47458 }
47459 {
47460 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
47461 }
47462 {
47463 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
47464 }
47465 {
47466 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
47467 }
47468 {
47469 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
47470 }
47471 {
47472 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
47473 }
47474 {
47475 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
47476 }
47477 {
47478 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
47479 }
47480 {
47481 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
47482 }
47483 {
47484 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
47485 }
47486 {
47487 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
47488 }
47489 {
47490 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
47491 }
47492 {
47493 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
47494 }
47495 {
47496 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
47497 }
47498 {
47499 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
47500 }
47501 {
47502 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
47503 }
47504 {
47505 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
47506 }
47507 {
47508 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
47509 }
47510 {
47511 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
47512 }
47513 {
47514 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
47515 }
47516 {
47517 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
47518 }
47519 {
47520 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
47521 }
47522 {
47523 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
47524 }
47525 {
47526 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
47527 }
47528 {
47529 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
47530 }
47531 {
47532 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
47533 }
47534 {
47535 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
47536 }
47537 {
47538 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
47539 }
47540 {
47541 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
47542 }
47543 {
47544 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
47545 }
47546 {
47547 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
47548 }
47549 {
47550 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
47551 }
47552 {
47553 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
47554 }
47555 {
47556 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
47557 }
47558 {
47559 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
47560 }
47561 {
47562 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
47563 }
47564 {
47565 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
47566 }
47567 {
47568 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
47569 }
47570 {
47571 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
47572 }
47573 {
47574 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
47575 }
47576 {
47577 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
47578 }
47579 {
47580 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
47581 }
47582 {
47583 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
47584 }
47585 {
47586 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
47587 }
47588 {
47589 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
47590 }
47591 {
47592 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
47593 }
47594 {
47595 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
47596 }
47597 {
47598 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
47599 }
47600 {
47601 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
47602 }
47603 {
47604 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
47605 }
47606 {
47607 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
47608 }
47609 {
47610 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
47611 }
47612 {
47613 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
47614 }
47615 {
47616 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
47617 }
47618 {
47619 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
47620 }
47621 {
47622 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
47623 }
47624 {
47625 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
47626 }
47627 {
47628 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
47629 }
47630 {
47631 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
47632 }
47633 {
47634 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
47635 }
47636 {
47637 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
47638 }
47639 {
47640 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
47641 }
47642 {
47643 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
47644 }
47645 {
47646 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
47647 }
47648 {
47649 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
47650 }
47651 {
47652 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
47653 }
47654 {
47655 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
47656 }
47657 {
47658 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
47659 }
47660 {
47661 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
47662 }
47663 {
47664 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
47665 }
47666 {
47667 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
47668 }
47669 {
47670 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
47671 }
47672 {
47673 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
47674 }
47675 {
47676 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
47677 }
47678 {
47679 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
47680 }
47681 {
47682 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
47683 }
47684 {
47685 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
47686 }
47687 {
47688 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
47689 }
47690 {
47691 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
47692 }
47693 {
47694 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
47695 }
47696 {
47697 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
47698 }
47699 {
47700 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
47701 }
47702 {
47703 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
47704 }
47705 {
47706 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
47707 }
47708 {
47709 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
47710 }
47711 {
47712 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
47713 }
47714 {
47715 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
47716 }
47717 {
47718 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
47719 }
47720 {
47721 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
47722 }
47723 {
47724 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
47725 }
47726 {
47727 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
47728 }
47729 {
47730 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
47731 }
47732 {
47733 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
47734 }
47735 {
47736 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
47737 }
47738 {
47739 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
47740 }
47741 {
47742 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
47743 }
47744 {
47745 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
47746 }
47747 {
47748 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
47749 }
47750 {
47751 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
47752 }
47753 {
47754 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
47755 }
47756 {
47757 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
47758 }
47759 {
47760 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
47761 }
47762 {
47763 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
47764 }
47765 {
47766 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
47767 }
47768 {
47769 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
47770 }
47771 {
47772 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
47773 }
47774 {
47775 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
47776 }
47777 {
47778 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
47779 }
47780 {
47781 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
47782 }
47783 {
47784 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
47785 }
47786 {
47787 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
47788 }
47789 {
47790 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
47791 }
47792 {
47793 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
47794 }
47795 {
47796 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
47797 }
47798 {
47799 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
47800 }
47801 {
47802 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
47803 }
47804 {
47805 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
47806 }
47807 {
47808 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
47809 }
47810 {
47811 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
47812 }
47813 {
47814 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
47815 }
47816 {
47817 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
47818 }
47819 {
47820 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
47821 }
47822 {
47823 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
47824 }
47825 {
47826 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
47827 }
47828 {
47829 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
47830 }
47831 {
47832 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
47833 }
47834 {
47835 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
47836 }
47837 {
47838 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
47839 }
47840 {
47841 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
47842 }
47843 {
47844 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
47845 }
47846 {
47847 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
47848 }
47849 {
47850 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
47851 }
47852 {
47853 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
47854 }
47855 {
47856 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
47857 }
47858 {
47859 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
47860 }
47861 {
47862 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
47863 }
47864 {
47865 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
47866 }
47867 {
47868 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
47869 }
47870 {
47871 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
47872 }
47873 {
47874 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
47875 }
47876 {
47877 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
47878 }
47879 {
47880 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
47881 }
47882 {
47883 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
47884 }
47885 {
47886 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
47887 }
47888 {
47889 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
47890 }
47891 {
47892 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
47893 }
47894 {
47895 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
47896 }
47897 {
47898 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
47899 }
47900 {
47901 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
47902 }
47903 {
47904 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
47905 }
47906 {
47907 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
47908 }
47909 {
47910 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
47911 }
47912 {
47913 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
47914 }
47915 {
47916 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
47917 }
47918 {
47919 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
47920 }
47921 {
47922 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
47923 }
47924 {
47925 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
47926 }
47927 {
47928 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
47929 }
47930 {
47931 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
47932 }
47933 {
47934 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
47935 }
47936 {
47937 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
47938 }
47939 {
47940 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
47941 }
47942 {
47943 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
47944 }
47945 {
47946 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
47947 }
47948 {
47949 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
47950 }
47951 {
47952 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
47953 }
47954 {
47955 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
47956 }
47957 {
47958 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
47959 }
47960 {
47961 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
47962 }
47963 {
47964 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
47965 }
47966 {
47967 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
47968 }
47969 {
47970 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
47971 }
47972 {
47973 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
47974 }
47975 {
47976 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
47977 }
47978 {
47979 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
47980 }
47981 {
47982 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
47983 }
47984 {
47985 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
47986 }
47987 {
47988 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
47989 }
47990 {
47991 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
47992 }
47993 {
47994 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
47995 }
47996 {
47997 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
47998 }
47999 {
48000 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48001 }
48002 {
48003 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48004 }
48005 {
48006 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48007 }
48008 {
48009 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48010 }
48011 {
48012 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48013 }
48014 {
48015 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48016 }
48017 {
48018 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48019 }
48020 {
48021 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48022 }
48023 {
48024 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48025 }
48026 {
48027 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
48028 }
48029 {
48030 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
48031 }
48032 {
48033 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
48034 }
48035 {
48036 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
48037 }
48038 {
48039 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
48040 }
48041 {
48042 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
48043 }
48044 {
48045 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
48046 }
48047 {
48048 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
48049 }
48050 {
48051 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
48052 }
48053 {
48054 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
48055 }
48056 {
48057 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
48058 }
48059 {
48060 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
48061 }
48062 {
48063 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
48064 }
48065 {
48066 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
48067 }
48068 {
48069 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
48070 }
48071 {
48072 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
48073 }
48074 {
48075 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
48076 }
48077 {
48078 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
48079 }
48080 {
48081 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
48082 }
48083 {
48084 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
48085 }
48086 {
48087 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
48088 }
48089 {
48090 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
48091 }
48092 {
48093 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
48094 }
48095 {
48096 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
48097 }
48098 {
48099 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
48100 }
48101 {
48102 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
48103 }
48104 {
48105 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
48106 }
48107 {
48108 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
48109 }
48110 {
48111 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
48112 }
48113 {
48114 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
48115 }
48116 {
48117 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
48118 }
48119 {
48120 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
48121 }
48122 {
48123 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
48124 }
48125 {
48126 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
48127 }
48128 {
48129 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
48130 }
48131 {
48132 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
48133 }
48134 {
48135 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
48136 }
48137 {
48138 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
48139 }
48140 {
48141 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
48142 }
48143 {
48144 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
48145 }
48146 {
48147 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
48148 }
48149 {
48150 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
48151 }
48152 {
48153 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
48154 }
48155 {
48156 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
48157 }
48158 {
48159 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
48160 }
48161 {
48162 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
48163 }
48164 {
48165 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
48166 }
48167 {
48168 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
48169 }
48170 {
48171 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
48172 }
48173 {
48174 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
48175 }
48176 {
48177 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
48178 }
48179 {
48180 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
48181 }
48182 {
48183 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
48184 }
48185 {
48186 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
48187 }
48188 {
48189 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
48190 }
48191 {
48192 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
48193 }
48194 {
48195 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
48196 }
48197 {
48198 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
48199 }
48200 {
48201 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
48202 }
48203 {
48204 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
48205 }
48206 {
48207 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
48208 }
48209 {
48210 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
48211 }
48212 {
48213 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
48214 }
48215 {
48216 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
48217 }
48218 {
48219 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
48220 }
48221 {
48222 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
48223 }
48224 {
48225 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
48226 }
48227 {
48228 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
48229 }
48230 {
48231 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
48232 }
48233 {
48234 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
48235 }
48236 {
48237 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
48238 }
48239 {
48240 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
48241 }
48242 {
48243 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
48244 }
48245 {
48246 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
48247 }
48248 {
48249 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
48250 }
48251 {
48252 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
48253 }
48254 {
48255 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
48256 }
48257 {
48258 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
48259 }
48260 {
48261 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
48262 }
48263 {
48264 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
48265 }
48266 {
48267 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
48268 }
48269 {
48270 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
48271 }
48272 {
48273 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
48274 }
48275 {
48276 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
48277 }
48278 {
48279 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
48280 }
48281 {
48282 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
48283 }
48284 {
48285 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
48286 }
48287 {
48288 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
48289 }
48290 {
48291 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
48292 }
48293 {
48294 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
48295 }
48296 {
48297 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
48298 }
48299 {
48300 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
48301 }
48302 {
48303 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
48304 }
48305 {
48306 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
48307 }
48308 {
48309 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
48310 }
48311 {
48312 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
48313 }
48314 {
48315 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
48316 }
48317 {
48318 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
48319 }
48320 {
48321 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
48322 }
48323 {
48324 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
48325 }
48326 {
48327 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
48328 }
48329 {
48330 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
48331 }
48332 {
48333 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
48334 }
48335 {
48336 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
48337 }
48338 {
48339 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
48340 }
48341 {
48342 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
48343 }
48344 {
48345 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
48346 }
48347 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
48348 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
48349 {
48350 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
48351 }
48352 {
48353 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
48354 }
48355 {
48356 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
48357 }
48358 {
48359 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
48360 }
48361 {
48362 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
48363 }
48364 {
48365 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
48366 }
48367 {
48368 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
48369 }
48370 {
48371 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
48372 }
48373 {
48374 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
48375 }
48376 {
48377 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
48378 }
48379 {
48380 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
48381 }
48382 {
48383 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
48384 }
48385 {
48386 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
48387 }
48388 {
48389 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
48390 }
48391 {
48392 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
48393 }
48394 {
48395 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
48396 }
48397 {
48398 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
48399 }
48400 {
48401 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
48402 }
48403 {
48404 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
48405 }
48406 {
48407 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
48408 }
48409 {
48410 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
48411 }
48412 {
48413 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
48414 }
48415 {
48416 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
48417 }
48418 {
48419 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
48420 }
48421 {
48422 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
48423 }
48424 {
48425 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
48426 }
48427 {
48428 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
48429 }
48430 {
48431 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
48432 }
48433 {
48434 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
48435 }
48436 {
48437 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
48438 }
48439 {
48440 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
48441 }
48442 {
48443 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
48444 }
48445 {
48446 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
48447 }
48448 {
48449 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
48450 }
48451 {
48452 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
48453 }
48454 {
48455 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
48456 }
48457 {
48458 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
48459 }
48460 {
48461 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
48462 }
48463 {
48464 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
48465 }
48466 {
48467 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
48468 }
48469 {
48470 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
48471 }
48472 {
48473 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
48474 }
48475 {
48476 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
48477 }
48478 {
48479 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
48480 }
48481 {
48482 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
48483 }
48484 {
48485 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
48486 }
48487 {
48488 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
48489 }
48490 {
48491 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
48492 }
48493 {
48494 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
48495 }
48496 {
48497 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
48498 }
48499 {
48500 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
48501 }
48502 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
48503 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
48504 {
48505 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
48506 }
48507 {
48508 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
48509 }
48510 {
48511 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
48512 }
48513
48514 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
48515
48516
48517 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
48518
48519 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
48520 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
48521 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
48522 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
48523 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
48524 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
48525 {
48526 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
48527 }
48528 {
48529 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
48530 }
48531 {
48532 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
48533 }
48534 {
48535 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
48536 }
48537 {
48538 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
48539 }
48540 {
48541 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
48542 }
48543 {
48544 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
48545 }
48546 {
48547 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
48548 }
48549 {
48550 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
48551 }
48552 {
48553 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
48554 }
48555 {
48556 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
48557 }
48558 {
48559 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
48560 }
48561 {
48562 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
48563 }
48564 {
48565 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
48566 }
48567 {
48568 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
48569 }
48570 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
48571 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
48572 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
48573 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
48574 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
48575 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
48576 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
48577 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
48578 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
48579 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
48580 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
48581 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
48582 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
48583 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
48584 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
48585 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
48586 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
48587 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
48588 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
48589 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
48590 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
48591 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
48592 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
48593 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
48594 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
48595 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
48596 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
48597 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
48598 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
48599 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
48600 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
48601 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
48602 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
48603 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
48604 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
48605 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
48606 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
48607 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
48608 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
48609 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
48610 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
48611 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
48612 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
48613 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
48614 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
48615 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
48616 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
48617 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
48618 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
48619 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
48620 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
48621 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
48622 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
48623 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
48624 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
48625 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
48626 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
48627 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
48628 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
48629 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
48630 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
48631 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
48632 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
48633 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
48634 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
48635 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
48636 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
48637 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
48638 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
48639 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
48640 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
48641 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
48642 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
48643 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
48644 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
48645 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
48646 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
48647 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
48648 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
48649 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
48650 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
48651 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
48652 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
48653 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
48654 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
48655 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
48656 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
48657 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
48658 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
48659 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
48660 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
48661 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
48662 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
48663 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
48664 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
48665 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
48666 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
48667 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
48668 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
48669 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
48670 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
48671 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
48672 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
48673 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
48674 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
48675 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
48676 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
48677 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
48678 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
48679 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
48680 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
48681 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
48682 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
48683 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
48684 {
48685 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
48686 }
48687 {
48688 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
48689 }
48690 {
48691 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
48692 }
48693 {
48694 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
48695 }
48696 {
48697 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
48698 }
48699 {
48700 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
48701 }
48702 {
48703 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
48704 }
48705 {
48706 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
48707 }
48708 {
48709 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
48710 }
48711 {
48712 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
48713 }
48714 {
48715 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
48716 }
48717 {
48718 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
48719 }
48720 {
48721 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
48722 }
48723 {
48724 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
48725 }
48726 {
48727 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
48728 }
48729 {
48730 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
48731 }
48732 {
48733 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
48734 }
48735 {
48736 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
48737 }
48738 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
48739 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
48740 {
48741 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
48742 }
48743 {
48744 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
48745 }
48746 {
48747 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
48748 }
48749 {
48750 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
48751 }
48752 {
48753 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
48754 }
48755 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
48756 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
48757 {
48758 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
48759 }
48760 {
48761 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
48762 }
48763 {
48764 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
48765 }
48766 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
48767 {
48768 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
48769 }
48770 {
48771 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
48772 }
48773 {
48774 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
48775 }
48776 {
48777 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
48778 }
48779 {
48780 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
48781 }
48782 {
48783 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
48784 }
48785 {
48786 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
48787 }
48788 {
48789 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
48790 }
48791 {
48792 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
48793 }
48794 {
48795 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
48796 }
48797 {
48798 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
48799 }
48800 {
48801 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
48802 }
48803 {
48804 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
48805 }
48806 {
48807 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
48808 }
48809 {
48810 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
48811 }
48812 {
48813 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
48814 }
48815 {
48816 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
48817 }
48818 {
48819 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
48820 }
48821 {
48822 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
48823 }
48824
48825 // Initialize threading, some globals and such
48826 __wxPyPreStart(d);
48827
48828
48829 // Although these are defined in __version__ they need to be here too so
48830 // that an assert can be done to ensure that the wxPython and the wxWindows
48831 // versions match.
48832 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
48833 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
48834 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
48835
48836 }
48837
wxWidgets (Impactor)