]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
new layout was messing with separator positions
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_wxMenu swig_types[14]
1356 #define SWIGTYPE_p_wxGridSizer swig_types[15]
1357 #define SWIGTYPE_p_wxFlexGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxInitDialogEvent swig_types[17]
1359 #define SWIGTYPE_p_wxItemContainer swig_types[18]
1360 #define SWIGTYPE_p_wxNcPaintEvent swig_types[19]
1361 #define SWIGTYPE_p_wxPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[21]
1363 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxControl swig_types[25]
1367 #define SWIGTYPE_p_wxFont swig_types[26]
1368 #define SWIGTYPE_p_wxMenuBarBase swig_types[27]
1369 #define SWIGTYPE_p_wxSetCursorEvent swig_types[28]
1370 #define SWIGTYPE_p_wxFSFile swig_types[29]
1371 #define SWIGTYPE_p_wxCaret swig_types[30]
1372 #define SWIGTYPE_ptrdiff_t swig_types[31]
1373 #define SWIGTYPE_std__ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_p_wxRegion swig_types[33]
1375 #define SWIGTYPE_p_wxPoint2D swig_types[34]
1376 #define SWIGTYPE_p_int swig_types[35]
1377 #define SWIGTYPE_p_wxSize swig_types[36]
1378 #define SWIGTYPE_p_wxDC swig_types[37]
1379 #define SWIGTYPE_p_wxPySizer swig_types[38]
1380 #define SWIGTYPE_p_wxVisualAttributes swig_types[39]
1381 #define SWIGTYPE_p_wxNotifyEvent swig_types[40]
1382 #define SWIGTYPE_p_wxPyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPropagationDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxAppTraits swig_types[44]
1386 #define SWIGTYPE_p_wxArrayString swig_types[45]
1387 #define SWIGTYPE_p_wxShowEvent swig_types[46]
1388 #define SWIGTYPE_p_wxToolTip swig_types[47]
1389 #define SWIGTYPE_p_wxMoveEvent swig_types[48]
1390 #define SWIGTYPE_p_wxSizeEvent swig_types[49]
1391 #define SWIGTYPE_p_wxActivateEvent swig_types[50]
1392 #define SWIGTYPE_p_wxIconizeEvent swig_types[51]
1393 #define SWIGTYPE_p_wxMaximizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[53]
1395 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[54]
1396 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
1397 #define SWIGTYPE_p_wxDateEvent swig_types[56]
1398 #define SWIGTYPE_p_wxMenuItem swig_types[57]
1399 #define SWIGTYPE_p_wxStaticBox swig_types[58]
1400 #define SWIGTYPE_p_long swig_types[59]
1401 #define SWIGTYPE_p_wxDuplexMode swig_types[60]
1402 #define SWIGTYPE_p_wxTIFFHandler swig_types[61]
1403 #define SWIGTYPE_p_wxXPMHandler swig_types[62]
1404 #define SWIGTYPE_p_wxPNMHandler swig_types[63]
1405 #define SWIGTYPE_p_wxJPEGHandler swig_types[64]
1406 #define SWIGTYPE_p_wxPCXHandler swig_types[65]
1407 #define SWIGTYPE_p_wxGIFHandler swig_types[66]
1408 #define SWIGTYPE_p_wxPNGHandler swig_types[67]
1409 #define SWIGTYPE_p_wxANIHandler swig_types[68]
1410 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
1411 #define SWIGTYPE_p_wxZipFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxInternetFSHandler swig_types[71]
1413 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[72]
1414 #define SWIGTYPE_p_wxEvtHandler swig_types[73]
1415 #define SWIGTYPE_p_wxCURHandler swig_types[74]
1416 #define SWIGTYPE_p_wxICOHandler swig_types[75]
1417 #define SWIGTYPE_p_wxBMPHandler swig_types[76]
1418 #define SWIGTYPE_p_wxImageHandler swig_types[77]
1419 #define SWIGTYPE_p_wxFileSystemHandler swig_types[78]
1420 #define SWIGTYPE_p_wxRect swig_types[79]
1421 #define SWIGTYPE_p_wxButton swig_types[80]
1422 #define SWIGTYPE_p_wxGBSpan swig_types[81]
1423 #define SWIGTYPE_p_wxPropagateOnce swig_types[82]
1424 #define SWIGTYPE_p_wxAcceleratorTable swig_types[83]
1425 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[84]
1426 #define SWIGTYPE_p_char swig_types[85]
1427 #define SWIGTYPE_p_wxGBPosition swig_types[86]
1428 #define SWIGTYPE_p_wxImage swig_types[87]
1429 #define SWIGTYPE_p_wxFrame swig_types[88]
1430 #define SWIGTYPE_p_wxScrollWinEvent swig_types[89]
1431 #define SWIGTYPE_p_wxPaperSize swig_types[90]
1432 #define SWIGTYPE_p_wxImageHistogram swig_types[91]
1433 #define SWIGTYPE_p_wxPoint swig_types[92]
1434 #define SWIGTYPE_p_wxCursor swig_types[93]
1435 #define SWIGTYPE_p_wxObject swig_types[94]
1436 #define SWIGTYPE_p_wxInputStream swig_types[95]
1437 #define SWIGTYPE_p_wxOutputStream swig_types[96]
1438 #define SWIGTYPE_p_wxPyInputStream swig_types[97]
1439 #define SWIGTYPE_p_wxDateTime swig_types[98]
1440 #define SWIGTYPE_p_wxKeyEvent swig_types[99]
1441 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[100]
1442 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[101]
1443 #define SWIGTYPE_p_unsigned_long swig_types[102]
1444 #define SWIGTYPE_p_wxWindow swig_types[103]
1445 #define SWIGTYPE_p_wxMenuBar swig_types[104]
1446 #define SWIGTYPE_p_wxFileSystem swig_types[105]
1447 #define SWIGTYPE_p_wxBitmap swig_types[106]
1448 #define SWIGTYPE_unsigned_int swig_types[107]
1449 #define SWIGTYPE_p_unsigned_int swig_types[108]
1450 #define SWIGTYPE_p_wxMenuEvent swig_types[109]
1451 #define SWIGTYPE_p_wxContextMenuEvent swig_types[110]
1452 #define SWIGTYPE_p_unsigned_char swig_types[111]
1453 #define SWIGTYPE_p_wxEraseEvent swig_types[112]
1454 #define SWIGTYPE_p_wxMouseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxCloseEvent swig_types[114]
1456 #define SWIGTYPE_p_wxPyApp swig_types[115]
1457 #define SWIGTYPE_p_wxCommandEvent swig_types[116]
1458 #define SWIGTYPE_p_wxPyCommandEvent swig_types[117]
1459 #define SWIGTYPE_p_wxPyDropTarget swig_types[118]
1460 #define SWIGTYPE_p_wxQuantize swig_types[119]
1461 #define SWIGTYPE_p_wxChildFocusEvent swig_types[120]
1462 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1463 #define SWIGTYPE_p_wxDropFilesEvent swig_types[122]
1464 #define SWIGTYPE_p_wxControlWithItems swig_types[123]
1465 #define SWIGTYPE_p_wxColour swig_types[124]
1466 #define SWIGTYPE_p_wxValidator swig_types[125]
1467 #define SWIGTYPE_p_wxPyValidator swig_types[126]
1468 static swig_type_info *swig_types[128];
1469
1470 /* -------- TYPES TABLE (END) -------- */
1471
1472
1473 /*-----------------------------------------------
1474 @(target):= _core_.so
1475 ------------------------------------------------*/
1476 #define SWIG_init init_core_
1477
1478 #define SWIG_name "_core_"
1479
1480 #include "wx/wxPython/wxPython_int.h"
1481 #include "wx/wxPython/pyclasses.h"
1482
1483
1484 #ifndef wxPyUSE_EXPORT
1485 // Helper functions for dealing with SWIG objects and such. These are
1486 // located here so they know about the SWIG types and functions declared
1487 // in the wrapper code.
1488
1489 #include <wx/hashmap.h>
1490 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1491
1492
1493 // Maintains a hashmap of className to swig_type_info pointers. Given the
1494 // name of a class either looks up the type info in the cache, or scans the
1495 // SWIG tables for it.
1496 extern PyObject* wxPyPtrTypeMap;
1497 static
1498 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1499
1500 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1501
1502 if (typeInfoCache == NULL)
1503 typeInfoCache = new wxPyTypeInfoHashMap;
1504
1505 wxString name(className);
1506 swig_type_info* swigType = (*typeInfoCache)[name];
1507
1508 if (! swigType) {
1509 // it wasn't in the cache, so look it up from SWIG
1510 name.Append(wxT(" *"));
1511 swigType = SWIG_TypeQuery(name.mb_str());
1512
1513 // if it still wasn't found, try looking for a mapped name
1514 if (!swigType) {
1515 PyObject* item;
1516 name = className;
1517
1518 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1519 (char*)(const char*)name.mbc_str())) != NULL) {
1520 name = wxString(PyString_AsString(item), *wxConvCurrent);
1521 name.Append(wxT(" *"));
1522 swigType = SWIG_TypeQuery(name.mb_str());
1523 }
1524 }
1525 if (swigType) {
1526 // and add it to the map if found
1527 (*typeInfoCache)[className] = swigType;
1528 }
1529 }
1530 return swigType;
1531 }
1532
1533
1534 // Check if a class name is a type known to SWIG
1535 bool wxPyCheckSwigType(const wxChar* className) {
1536
1537 swig_type_info* swigType = wxPyFindSwigType(className);
1538 return swigType != NULL;
1539 }
1540
1541
1542 // Given a pointer to a C++ object and a class name, construct a Python proxy
1543 // object for it.
1544 PyObject* wxPyConstructObject(void* ptr,
1545 const wxChar* className,
1546 int setThisOwn) {
1547
1548 swig_type_info* swigType = wxPyFindSwigType(className);
1549 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1550
1551 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1552 }
1553
1554
1555 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1556 // Ensures that the proxy object is of the specified (or derived) type. If
1557 // not able to perform the conversion then a Python exception is set and the
1558 // error should be handled properly in the caller. Returns True on success.
1559 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1560 const wxChar* className) {
1561
1562 swig_type_info* swigType = wxPyFindSwigType(className);
1563 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1564
1565 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1566 }
1567
1568
1569 // Make a SWIGified pointer object suitable for a .this attribute
1570 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1571
1572 PyObject* robj = NULL;
1573
1574 swig_type_info* swigType = wxPyFindSwigType(className);
1575 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1576
1577 #ifdef SWIG_COBJECT_TYPES
1578 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1579 #else
1580 {
1581 char result[1024];
1582 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1583 PyString_FromString(result) : 0;
1584 }
1585 #endif
1586
1587 return robj;
1588 }
1589
1590
1591
1592
1593 // Export a C API in a struct. Other modules will be able to load this from
1594 // the wx._core_ module and will then have safe access to these functions,
1595 // even if they are located in another shared library.
1596 static wxPyCoreAPI API = {
1597
1598 wxPyCheckSwigType,
1599 wxPyConstructObject,
1600 wxPyConvertSwigPtr,
1601 wxPyMakeSwigPtr,
1602
1603 wxPyBeginAllowThreads,
1604 wxPyEndAllowThreads,
1605 wxPyBeginBlockThreads,
1606 wxPyEndBlockThreads,
1607
1608 wxPy_ConvertList,
1609
1610 wxString_in_helper,
1611 Py2wxString,
1612 wx2PyString,
1613
1614 byte_LIST_helper,
1615 int_LIST_helper,
1616 long_LIST_helper,
1617 string_LIST_helper,
1618 wxPoint_LIST_helper,
1619 wxBitmap_LIST_helper,
1620 wxString_LIST_helper,
1621 wxAcceleratorEntry_LIST_helper,
1622
1623 wxSize_helper,
1624 wxPoint_helper,
1625 wxRealPoint_helper,
1626 wxRect_helper,
1627 wxColour_helper,
1628 wxPoint2D_helper,
1629
1630 wxPySimple_typecheck,
1631 wxColour_typecheck,
1632
1633 wxPyCBH_setCallbackInfo,
1634 wxPyCBH_findCallback,
1635 wxPyCBH_callCallback,
1636 wxPyCBH_callCallbackObj,
1637 wxPyCBH_delete,
1638
1639 wxPyMake_wxObject,
1640 wxPyMake_wxSizer,
1641 wxPyPtrTypeMap_Add,
1642 wxPy2int_seq_helper,
1643 wxPy4int_seq_helper,
1644 wxArrayString2PyList_helper,
1645 wxArrayInt2PyList_helper,
1646
1647 wxPyClientData_dtor,
1648 wxPyUserData_dtor,
1649 wxPyOORClientData_dtor,
1650
1651 wxPyCBInputStream_create,
1652
1653 wxPyInstance_Check,
1654 wxPySwigInstance_Check,
1655
1656 wxPyCheckForApp
1657
1658 };
1659
1660 #endif
1661
1662
1663 #if !WXWIN_COMPATIBILITY_2_4
1664 #define wxHIDE_READONLY 0
1665 #endif
1666
1667
1668 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1669 #define SWIG_From_int PyInt_FromLong
1670 /*@@*/
1671
1672
1673 #if ! wxUSE_HOTKEY
1674 enum wxHotkeyModifier
1675 {
1676 wxMOD_NONE = 0,
1677 wxMOD_ALT = 1,
1678 wxMOD_CONTROL = 2,
1679 wxMOD_SHIFT = 4,
1680 wxMOD_WIN = 8
1681 };
1682 #define wxEVT_HOTKEY 9999
1683 #endif
1684
1685 static const wxString wxPyEmptyString(wxEmptyString);
1686 static wxString wxObject_GetClassName(wxObject *self){
1687 return self->GetClassInfo()->GetClassName();
1688 }
1689 static void wxObject_Destroy(wxObject *self){
1690 delete self;
1691 }
1692
1693 #ifndef __WXMAC__
1694 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1695 #endif
1696
1697
1698 #include <limits.h>
1699
1700
1701 SWIGINTERN int
1702 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1703 const char *errmsg)
1704 {
1705 if (value < min_value) {
1706 if (errmsg) {
1707 PyErr_Format(PyExc_OverflowError,
1708 "value %ld is less than '%s' minimum %ld",
1709 value, errmsg, min_value);
1710 }
1711 return 0;
1712 } else if (value > max_value) {
1713 if (errmsg) {
1714 PyErr_Format(PyExc_OverflowError,
1715 "value %ld is greater than '%s' maximum %ld",
1716 value, errmsg, max_value);
1717 }
1718 return 0;
1719 }
1720 return 1;
1721 }
1722
1723
1724 SWIGINTERN int
1725 SWIG_AsVal_long(PyObject* obj, long* val)
1726 {
1727 if (PyNumber_Check(obj)) {
1728 if (val) *val = PyInt_AsLong(obj);
1729 return 1;
1730 }
1731 else {
1732 SWIG_type_error("number", obj);
1733 }
1734 return 0;
1735 }
1736
1737
1738 #if INT_MAX != LONG_MAX
1739 SWIGINTERN int
1740 SWIG_AsVal_int(PyObject *obj, int *val)
1741 {
1742 const char* errmsg = val ? "int" : (char*)0;
1743 long v;
1744 if (SWIG_AsVal_long(obj, &v)) {
1745 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1746 if (val) *val = (int)(v);
1747 return 1;
1748 } else {
1749 return 0;
1750 }
1751 } else {
1752 PyErr_Clear();
1753 }
1754 if (val) {
1755 SWIG_type_error(errmsg, obj);
1756 }
1757 return 0;
1758 }
1759 #else
1760 SWIGINTERNSHORT int
1761 SWIG_AsVal_int(PyObject *obj, int *val)
1762 {
1763 return SWIG_AsVal_long(obj,(long*)val);
1764 }
1765 #endif
1766
1767
1768 SWIGINTERNSHORT int
1769 SWIG_As_int(PyObject* obj)
1770 {
1771 int v;
1772 if (!SWIG_AsVal_int(obj, &v)) {
1773 /*
1774 this is needed to make valgrind/purify happier.
1775 */
1776 memset((void*)&v, 0, sizeof(int));
1777 }
1778 return v;
1779 }
1780
1781
1782 SWIGINTERNSHORT int
1783 SWIG_Check_int(PyObject* obj)
1784 {
1785 return SWIG_AsVal_int(obj, (int*)0);
1786 }
1787
1788 static PyObject *wxSize_Get(wxSize *self){
1789 bool blocked = wxPyBeginBlockThreads();
1790 PyObject* tup = PyTuple_New(2);
1791 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1792 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1793 wxPyEndBlockThreads(blocked);
1794 return tup;
1795 }
1796
1797 SWIGINTERN int
1798 SWIG_AsVal_double(PyObject *obj, double* val)
1799 {
1800 if (PyNumber_Check(obj)) {
1801 if (val) *val = PyFloat_AsDouble(obj);
1802 return 1;
1803 }
1804 else {
1805 SWIG_type_error("number", obj);
1806 }
1807 return 0;
1808 }
1809
1810
1811 SWIGINTERNSHORT double
1812 SWIG_As_double(PyObject* obj)
1813 {
1814 double v;
1815 if (!SWIG_AsVal_double(obj, &v)) {
1816 /*
1817 this is needed to make valgrind/purify happier.
1818 */
1819 memset((void*)&v, 0, sizeof(double));
1820 }
1821 return v;
1822 }
1823
1824
1825 SWIGINTERNSHORT int
1826 SWIG_Check_double(PyObject* obj)
1827 {
1828 return SWIG_AsVal_double(obj, (double*)0);
1829 }
1830
1831
1832 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1833 #define SWIG_From_double PyFloat_FromDouble
1834 /*@@*/
1835
1836 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1837 self->x = x;
1838 self->y = y;
1839 }
1840 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1841 bool blocked = wxPyBeginBlockThreads();
1842 PyObject* tup = PyTuple_New(2);
1843 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1844 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1845 wxPyEndBlockThreads(blocked);
1846 return tup;
1847 }
1848
1849 SWIGINTERNSHORT long
1850 SWIG_As_long(PyObject* obj)
1851 {
1852 long v;
1853 if (!SWIG_AsVal_long(obj, &v)) {
1854 /*
1855 this is needed to make valgrind/purify happier.
1856 */
1857 memset((void*)&v, 0, sizeof(long));
1858 }
1859 return v;
1860 }
1861
1862
1863 SWIGINTERNSHORT int
1864 SWIG_Check_long(PyObject* obj)
1865 {
1866 return SWIG_AsVal_long(obj, (long*)0);
1867 }
1868
1869 static void wxPoint_Set(wxPoint *self,long x,long y){
1870 self->x = x;
1871 self->y = y;
1872 }
1873 static PyObject *wxPoint_Get(wxPoint *self){
1874 bool blocked = wxPyBeginBlockThreads();
1875 PyObject* tup = PyTuple_New(2);
1876 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1877 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1878 wxPyEndBlockThreads(blocked);
1879 return tup;
1880 }
1881 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1882 self->x = x;
1883 self->y = y;
1884 self->width = width;
1885 self->height = height;
1886 }
1887 static PyObject *wxRect_Get(wxRect *self){
1888 bool blocked = wxPyBeginBlockThreads();
1889 PyObject* tup = PyTuple_New(4);
1890 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1891 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1892 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1893 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1894 wxPyEndBlockThreads(blocked);
1895 return tup;
1896 }
1897
1898 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1899 wxRegion reg1(*r1);
1900 wxRegion reg2(*r2);
1901 wxRect dest(0,0,0,0);
1902 PyObject* obj;
1903
1904 reg1.Intersect(reg2);
1905 dest = reg1.GetBox();
1906
1907 if (dest != wxRect(0,0,0,0)) {
1908 bool blocked = wxPyBeginBlockThreads();
1909 wxRect* newRect = new wxRect(dest);
1910 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1911 wxPyEndBlockThreads(blocked);
1912 return obj;
1913 }
1914 Py_INCREF(Py_None);
1915 return Py_None;
1916 }
1917
1918
1919 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1920 PyObject* o2;
1921 PyObject* o3;
1922
1923 if (!target) {
1924 target = o;
1925 } else if (target == Py_None) {
1926 Py_DECREF(Py_None);
1927 target = o;
1928 } else {
1929 if (!PyTuple_Check(target)) {
1930 o2 = target;
1931 target = PyTuple_New(1);
1932 PyTuple_SetItem(target, 0, o2);
1933 }
1934 o3 = PyTuple_New(1);
1935 PyTuple_SetItem(o3, 0, o);
1936
1937 o2 = target;
1938 target = PySequence_Concat(o2, o3);
1939 Py_DECREF(o2);
1940 Py_DECREF(o3);
1941 }
1942 return target;
1943 }
1944
1945
1946 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1947 self->m_x = x;
1948 self->m_y = y;
1949 }
1950 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1951 bool blocked = wxPyBeginBlockThreads();
1952 PyObject* tup = PyTuple_New(2);
1953 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1954 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1955 wxPyEndBlockThreads(blocked);
1956 return tup;
1957 }
1958
1959 #include "wx/wxPython/pyistream.h"
1960
1961 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1962 wxInputStream* wxis = wxPyCBInputStream::create(p);
1963 if (wxis)
1964 return new wxPyInputStream(wxis);
1965 else
1966 return NULL;
1967 }
1968
1969 SWIGINTERNSHORT PyObject*
1970 SWIG_From_char(char c)
1971 {
1972 return PyString_FromStringAndSize(&c,1);
1973 }
1974
1975
1976 SWIGINTERNSHORT PyObject*
1977 SWIG_From_unsigned_SS_long(unsigned long value)
1978 {
1979 return (value > LONG_MAX) ?
1980 PyLong_FromUnsignedLong(value)
1981 : PyInt_FromLong((long)(value));
1982 }
1983
1984
1985 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1986 SWIGINTERN int
1987 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1988 {
1989 static swig_type_info* pchar_info = 0;
1990 char* vptr = 0;
1991 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1992 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1993 if (cptr) *cptr = vptr;
1994 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1995 return SWIG_OLDOBJ;
1996 } else {
1997 PyErr_Clear();
1998 if (PyString_Check(obj)) {
1999 if (cptr) {
2000 *cptr = PyString_AS_STRING(obj);
2001 if (psize) {
2002 *psize = PyString_GET_SIZE(obj) + 1;
2003 }
2004 }
2005 return SWIG_PYSTR;
2006 }
2007 }
2008 if (cptr) {
2009 SWIG_type_error("char *", obj);
2010 }
2011 return 0;
2012 }
2013
2014
2015 SWIGINTERN int
2016 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2017 {
2018 char* cptr; size_t csize;
2019 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2020 /* in C you can do:
2021
2022 char x[5] = "hello";
2023
2024 ie, assing the array using an extra '0' char.
2025 */
2026 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2027 if (csize <= size) {
2028 if (val) {
2029 if (csize) memcpy(val, cptr, csize);
2030 if (csize < size) memset(val + csize, 0, size - csize);
2031 }
2032 return 1;
2033 }
2034 }
2035 if (val) {
2036 PyErr_Format(PyExc_TypeError,
2037 "a char array of maximum size %lu is expected",
2038 (unsigned long) size);
2039 }
2040 return 0;
2041 }
2042
2043
2044 SWIGINTERN int
2045 SWIG_AsVal_char(PyObject *obj, char *val)
2046 {
2047 const char* errmsg = val ? "char" : (char*)0;
2048 long v;
2049 if (SWIG_AsVal_long(obj, &v)) {
2050 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2051 if (val) *val = (char)(v);
2052 return 1;
2053 } else {
2054 return 0;
2055 }
2056 } else {
2057 PyErr_Clear();
2058 return SWIG_AsCharArray(obj, val, 1);
2059 }
2060 }
2061
2062
2063 SWIGINTERNSHORT char
2064 SWIG_As_char(PyObject* obj)
2065 {
2066 char v;
2067 if (!SWIG_AsVal_char(obj, &v)) {
2068 /*
2069 this is needed to make valgrind/purify happier.
2070 */
2071 memset((void*)&v, 0, sizeof(char));
2072 }
2073 return v;
2074 }
2075
2076
2077 SWIGINTERNSHORT int
2078 SWIG_Check_char(PyObject* obj)
2079 {
2080 return SWIG_AsVal_char(obj, (char*)0);
2081 }
2082
2083
2084 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2085 #define SWIG_From_long PyInt_FromLong
2086 /*@@*/
2087
2088 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2089 // We use only strings for the streams, not unicode
2090 PyObject* str = PyObject_Str(obj);
2091 if (! str) {
2092 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2093 return;
2094 }
2095 self->Write(PyString_AS_STRING(str),
2096 PyString_GET_SIZE(str));
2097 Py_DECREF(str);
2098 }
2099
2100 #include "wx/wxPython/pyistream.h"
2101
2102
2103 class wxPyFileSystemHandler : public wxFileSystemHandler
2104 {
2105 public:
2106 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2107
2108 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2109 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2110 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2111 DEC_PYCALLBACK_STRING__pure(FindNext);
2112
2113 wxString GetProtocol(const wxString& location) {
2114 return wxFileSystemHandler::GetProtocol(location);
2115 }
2116
2117 wxString GetLeftLocation(const wxString& location) {
2118 return wxFileSystemHandler::GetLeftLocation(location);
2119 }
2120
2121 wxString GetAnchor(const wxString& location) {
2122 return wxFileSystemHandler::GetAnchor(location);
2123 }
2124
2125 wxString GetRightLocation(const wxString& location) {
2126 return wxFileSystemHandler::GetRightLocation(location);
2127 }
2128
2129 wxString GetMimeTypeFromExt(const wxString& location) {
2130 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2131 }
2132
2133 PYPRIVATE;
2134 };
2135
2136
2137 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2138 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2139 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2140 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2141
2142
2143 SWIGINTERN int
2144 SWIG_AsVal_bool(PyObject *obj, bool *val)
2145 {
2146 if (obj == Py_True) {
2147 if (val) *val = true;
2148 return 1;
2149 }
2150 if (obj == Py_False) {
2151 if (val) *val = false;
2152 return 1;
2153 }
2154 int res = 0;
2155 if (SWIG_AsVal_int(obj, &res)) {
2156 if (val) *val = res ? true : false;
2157 return 1;
2158 } else {
2159 PyErr_Clear();
2160 }
2161 if (val) {
2162 SWIG_type_error("bool", obj);
2163 }
2164 return 0;
2165 }
2166
2167
2168 SWIGINTERNSHORT bool
2169 SWIG_As_bool(PyObject* obj)
2170 {
2171 bool v;
2172 if (!SWIG_AsVal_bool(obj, &v)) {
2173 /*
2174 this is needed to make valgrind/purify happier.
2175 */
2176 memset((void*)&v, 0, sizeof(bool));
2177 }
2178 return v;
2179 }
2180
2181
2182 SWIGINTERNSHORT int
2183 SWIG_Check_bool(PyObject* obj)
2184 {
2185 return SWIG_AsVal_bool(obj, (bool*)0);
2186 }
2187
2188 static wxString FileSystem_URLToFileName(wxString const &url){
2189 wxFileName fname = wxFileSystem::URLToFileName(url);
2190 return fname.GetFullPath();
2191 }
2192
2193 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2194 wxImage& image,
2195 long type) {
2196 wxMemoryFSHandler::AddFile(filename, image, type);
2197 }
2198
2199 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2200 const wxBitmap& bitmap,
2201 long type) {
2202 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2203 }
2204
2205 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2206 PyObject* data) {
2207 if (! PyString_Check(data)) {
2208 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2209 "Expected string object"));
2210 return;
2211 }
2212
2213 bool blocked = wxPyBeginBlockThreads();
2214 void* ptr = (void*)PyString_AsString(data);
2215 size_t size = PyString_Size(data);
2216 wxPyEndBlockThreads(blocked);
2217
2218 wxMemoryFSHandler::AddFile(filename, ptr, size);
2219 }
2220
2221
2222 #include "wx/wxPython/pyistream.h"
2223
2224
2225 SWIGINTERN int
2226 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2227 {
2228 long v = 0;
2229 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2230 SWIG_type_error("unsigned number", obj);
2231 }
2232 else if (val)
2233 *val = (unsigned long)v;
2234 return 1;
2235 }
2236
2237
2238 SWIGINTERNSHORT int
2239 SWIG_CheckUnsignedLongInRange(unsigned long value,
2240 unsigned long max_value,
2241 const char *errmsg)
2242 {
2243 if (value > max_value) {
2244 if (errmsg) {
2245 PyErr_Format(PyExc_OverflowError,
2246 "value %lu is greater than '%s' minimum %lu",
2247 value, errmsg, max_value);
2248 }
2249 return 0;
2250 }
2251 return 1;
2252 }
2253
2254
2255 SWIGINTERN int
2256 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2257 {
2258 const char* errmsg = val ? "unsigned char" : (char*)0;
2259 unsigned long v;
2260 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2261 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2262 if (val) *val = (unsigned char)(v);
2263 return 1;
2264 } else {
2265 return 0;
2266 }
2267 } else {
2268 PyErr_Clear();
2269 }
2270 if (val) {
2271 SWIG_type_error(errmsg, obj);
2272 }
2273 return 0;
2274 }
2275
2276
2277 SWIGINTERNSHORT unsigned char
2278 SWIG_As_unsigned_SS_char(PyObject* obj)
2279 {
2280 unsigned char v;
2281 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2282 /*
2283 this is needed to make valgrind/purify happier.
2284 */
2285 memset((void*)&v, 0, sizeof(unsigned char));
2286 }
2287 return v;
2288 }
2289
2290
2291 SWIGINTERNSHORT int
2292 SWIG_Check_unsigned_SS_char(PyObject* obj)
2293 {
2294 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2295 }
2296
2297
2298 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2299 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2300 /*@@*/
2301
2302
2303 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2304 if (width > 0 && height > 0)
2305 return new wxImage(width, height, clear);
2306 else
2307 return new wxImage;
2308 }
2309 static wxImage *new_wxImage(wxBitmap const &bitmap){
2310 return new wxImage(bitmap.ConvertToImage());
2311 }
2312 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2313 // Copy the source data so the wxImage can clean it up later
2314 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2315 if (copy == NULL) {
2316 PyErr_NoMemory();
2317 return NULL;
2318 }
2319 memcpy(copy, data, width*height*3);
2320 return new wxImage(width, height, copy, false);
2321 }
2322 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2323 // Copy the source data so the wxImage can clean it up later
2324 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2325 if (dcopy == NULL) {
2326 PyErr_NoMemory();
2327 return NULL;
2328 }
2329 memcpy(dcopy, data, width*height*3);
2330 unsigned char* acopy = (unsigned char*)malloc(width*height);
2331 if (acopy == NULL) {
2332 PyErr_NoMemory();
2333 return NULL;
2334 }
2335 memcpy(acopy, alpha, width*height);
2336
2337 return new wxImage(width, height, dcopy, acopy, false);
2338 }
2339 static wxSize wxImage_GetSize(wxImage *self){
2340 wxSize size(self->GetWidth(), self->GetHeight());
2341 return size;
2342 }
2343 static PyObject *wxImage_GetData(wxImage *self){
2344 unsigned char* data = self->GetData();
2345 int len = self->GetWidth() * self->GetHeight() * 3;
2346 PyObject* rv;
2347 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2348 return rv;
2349 }
2350 static void wxImage_SetData(wxImage *self,PyObject *data){
2351 unsigned char* dataPtr;
2352
2353 if (! PyString_Check(data)) {
2354 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2355 "Expected string object"));
2356 return /* NULL */ ;
2357 }
2358
2359 size_t len = self->GetWidth() * self->GetHeight() * 3;
2360 dataPtr = (unsigned char*) malloc(len);
2361 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2362 self->SetData(dataPtr);
2363 // wxImage takes ownership of dataPtr...
2364 }
2365 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2366 unsigned char* data = self->GetData();
2367 int len = self->GetWidth() * self->GetHeight() * 3;
2368 PyObject* rv;
2369 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2370 return rv;
2371 }
2372 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2373 unsigned char* buffer;
2374 int size;
2375
2376 bool blocked = wxPyBeginBlockThreads();
2377 if (!PyArg_Parse(data, "t#", &buffer, &size))
2378 goto done;
2379
2380 if (size != self->GetWidth() * self->GetHeight() * 3) {
2381 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2382 goto done;
2383 }
2384 self->SetData(buffer);
2385 done:
2386 wxPyEndBlockThreads(blocked);
2387 }
2388 static PyObject *wxImage_GetAlphaData(wxImage *self){
2389 unsigned char* data = self->GetAlpha();
2390 if (! data) {
2391 RETURN_NONE();
2392 } else {
2393 int len = self->GetWidth() * self->GetHeight();
2394 PyObject* rv;
2395 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2396 return rv;
2397 }
2398 }
2399 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2400 unsigned char* dataPtr;
2401
2402 if (! PyString_Check(data)) {
2403 PyErr_SetString(PyExc_TypeError, "Expected string object");
2404 return /* NULL */ ;
2405 }
2406
2407 size_t len = self->GetWidth() * self->GetHeight();
2408 dataPtr = (unsigned char*) malloc(len);
2409 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2410 self->SetAlpha(dataPtr);
2411 // wxImage takes ownership of dataPtr...
2412 }
2413 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2414 unsigned char* data = self->GetAlpha();
2415 int len = self->GetWidth() * self->GetHeight();
2416 PyObject* rv;
2417 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2418 return rv;
2419 }
2420 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2421 unsigned char* buffer;
2422 int size;
2423
2424 bool blocked = wxPyBeginBlockThreads();
2425 if (!PyArg_Parse(data, "t#", &buffer, &size))
2426 goto done;
2427
2428 if (size != self->GetWidth() * self->GetHeight()) {
2429 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2430 goto done;
2431 }
2432 self->SetAlpha(buffer);
2433 done:
2434 wxPyEndBlockThreads(blocked);
2435 }
2436
2437 SWIGINTERNSHORT unsigned long
2438 SWIG_As_unsigned_SS_long(PyObject* obj)
2439 {
2440 unsigned long v;
2441 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2442 /*
2443 this is needed to make valgrind/purify happier.
2444 */
2445 memset((void*)&v, 0, sizeof(unsigned long));
2446 }
2447 return v;
2448 }
2449
2450
2451 SWIGINTERNSHORT int
2452 SWIG_Check_unsigned_SS_long(PyObject* obj)
2453 {
2454 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2455 }
2456
2457 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2458 wxBitmap bitmap(*self, depth);
2459 return bitmap;
2460 }
2461 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2462 wxImage mono = self->ConvertToMono( red, green, blue );
2463 wxBitmap bitmap( mono, 1 );
2464 return bitmap;
2465 }
2466 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2467 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2468 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2469 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2470 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2471
2472 #include <wx/quantize.h>
2473
2474 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2475 return wxQuantize::Quantize(src, dest,
2476 //NULL, // palette
2477 desiredNoColours,
2478 NULL, // eightBitData
2479 flags);
2480 }
2481 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2482 if (PyCallable_Check(func)) {
2483 self->Connect(id, lastId, eventType,
2484 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2485 new wxPyCallback(func));
2486 }
2487 else if (func == Py_None) {
2488 self->Disconnect(id, lastId, eventType,
2489 (wxObjectEventFunction)
2490 &wxPyCallback::EventThunker);
2491 }
2492 else {
2493 wxPyBLOCK_THREADS(
2494 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2495 }
2496 }
2497 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2498 return self->Disconnect(id, lastId, eventType,
2499 (wxObjectEventFunction)
2500 &wxPyCallback::EventThunker);
2501 }
2502 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2503 if (_self && _self != Py_None) {
2504 self->SetClientObject(new wxPyOORClientData(_self, incref));
2505 }
2506 else {
2507 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2508 if (data) {
2509 self->SetClientObject(NULL); // This will delete it too
2510 }
2511 }
2512 }
2513
2514 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2515 #if wxUSE_UNICODE
2516 return self->GetUnicodeKey();
2517 #else
2518 return 0;
2519 #endif
2520 }
2521
2522 #if UINT_MAX < LONG_MAX
2523 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2524 #define SWIG_From_unsigned_SS_int SWIG_From_long
2525 /*@@*/
2526 #else
2527 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2528 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2529 /*@@*/
2530 #endif
2531
2532
2533 #if UINT_MAX != ULONG_MAX
2534 SWIGINTERN int
2535 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2536 {
2537 const char* errmsg = val ? "unsigned int" : (char*)0;
2538 unsigned long v;
2539 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2540 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2541 if (val) *val = (unsigned int)(v);
2542 return 1;
2543 }
2544 } else {
2545 PyErr_Clear();
2546 }
2547 if (val) {
2548 SWIG_type_error(errmsg, obj);
2549 }
2550 return 0;
2551 }
2552 #else
2553 SWIGINTERNSHORT unsigned int
2554 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2555 {
2556 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2557 }
2558 #endif
2559
2560
2561 SWIGINTERNSHORT unsigned int
2562 SWIG_As_unsigned_SS_int(PyObject* obj)
2563 {
2564 unsigned int v;
2565 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2566 /*
2567 this is needed to make valgrind/purify happier.
2568 */
2569 memset((void*)&v, 0, sizeof(unsigned int));
2570 }
2571 return v;
2572 }
2573
2574
2575 SWIGINTERNSHORT int
2576 SWIG_Check_unsigned_SS_int(PyObject* obj)
2577 {
2578 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2579 }
2580
2581 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2582 self->m_size = size;
2583 }
2584 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2585 int count = self->GetNumberOfFiles();
2586 wxString* files = self->GetFiles();
2587 PyObject* list = PyList_New(count);
2588
2589 if (!list) {
2590 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2591 return NULL;
2592 }
2593
2594 for (int i=0; i<count; i++) {
2595 PyList_SetItem(list, i, wx2PyString(files[i]));
2596 }
2597 return list;
2598 }
2599
2600
2601 static wxPyApp *new_wxPyApp(){
2602 wxPythonApp = new wxPyApp();
2603 return wxPythonApp;
2604 }
2605 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2606
2607 void wxApp_CleanUp() {
2608 __wxPyCleanup();
2609 }
2610
2611
2612 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2613
2614
2615 SWIGINTERNSHORT int
2616 SWIG_AsCharPtr(PyObject *obj, char **val)
2617 {
2618 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2619 return 1;
2620 }
2621 if (val) {
2622 PyErr_Clear();
2623 SWIG_type_error("char *", obj);
2624 }
2625 return 0;
2626 }
2627
2628
2629 SWIGINTERN PyObject *
2630 SWIG_FromCharPtr(const char* cptr)
2631 {
2632 if (cptr) {
2633 size_t size = strlen(cptr);
2634 if (size > INT_MAX) {
2635 return SWIG_NewPointerObj((char*)(cptr),
2636 SWIG_TypeQuery("char *"), 0);
2637 } else {
2638 if (size != 0) {
2639 return PyString_FromStringAndSize(cptr, size);
2640 } else {
2641 return PyString_FromString(cptr);
2642 }
2643 }
2644 }
2645 Py_INCREF(Py_None);
2646 return Py_None;
2647 }
2648
2649
2650 #ifdef __WXMAC__
2651
2652 // A dummy class that raises an exception if used...
2653 class wxEventLoop
2654 {
2655 public:
2656 wxEventLoop() { wxPyRaiseNotImplemented(); }
2657 int Run() { return 0; }
2658 void Exit(int rc = 0) {}
2659 bool Pending() const { return false; }
2660 bool Dispatch() { return false; }
2661 bool IsRunning() const { return false; }
2662 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2663 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2664 };
2665
2666 #else
2667
2668 #include <wx/evtloop.h>
2669
2670 #endif
2671
2672
2673
2674 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2675 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2676 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2677 static PyObject *wxWindow_GetChildren(wxWindow *self){
2678 wxWindowList& list = self->GetChildren();
2679 return wxPy_ConvertList(&list);
2680 }
2681 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2682 #if wxUSE_HOTKEY
2683 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2684 #else
2685 return false;
2686 #endif
2687 }
2688 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2689
2690
2691
2692 return false;
2693
2694 }
2695 static long wxWindow_GetHandle(wxWindow *self){
2696 return wxPyGetWinHandle(self);
2697 }
2698 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2699 self->AssociateHandle((WXWidget)handle);
2700 }
2701
2702 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2703 return wxWindow::FindWindowById(id, parent);
2704 }
2705
2706 wxWindow* wxFindWindowByName( const wxString& name,
2707 const wxWindow *parent = NULL ) {
2708 return wxWindow::FindWindowByName(name, parent);
2709 }
2710
2711 wxWindow* wxFindWindowByLabel( const wxString& label,
2712 const wxWindow *parent = NULL ) {
2713 return wxWindow::FindWindowByLabel(label, parent);
2714 }
2715
2716
2717 #ifdef __WXMSW__
2718 #include <wx/msw/private.h> // to get wxGetWindowId
2719 #endif
2720
2721
2722 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2723 #ifdef __WXMSW__
2724 WXHWND hWnd = (WXHWND)_hWnd;
2725 long id = wxGetWindowId(hWnd);
2726 wxWindow* win = new wxWindow;
2727 parent->AddChild(win);
2728 win->SetEventHandler(win);
2729 win->SetHWND(hWnd);
2730 win->SetId(id);
2731 win->SubclassWin(hWnd);
2732 win->AdoptAttributesFromHWND();
2733 win->SetupColours();
2734 return win;
2735 #else
2736 wxPyRaiseNotImplemented();
2737 return NULL;
2738 #endif
2739 }
2740
2741
2742 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2743 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2744 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2745
2746 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2747
2748 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2749 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2750 wxMenuItemList& list = self->GetMenuItems();
2751 return wxPy_ConvertList(&list);
2752 }
2753 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2754 static const wxString wxPyControlNameStr(wxControlNameStr);
2755 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2756 if (clientData) {
2757 wxPyClientData* data = new wxPyClientData(clientData);
2758 return self->Append(item, data);
2759 } else
2760 return self->Append(item);
2761 }
2762 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2763 if (clientData) {
2764 wxPyClientData* data = new wxPyClientData(clientData);
2765 return self->Insert(item, pos, data);
2766 } else
2767 return self->Insert(item, pos);
2768 }
2769 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2770 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2771 if (data) {
2772 Py_INCREF(data->m_obj);
2773 return data->m_obj;
2774 } else {
2775 Py_INCREF(Py_None);
2776 return Py_None;
2777 }
2778 }
2779 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2780 wxPyClientData* data = new wxPyClientData(clientData);
2781 self->SetClientObject(n, data);
2782 }
2783
2784
2785 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2786 wxPyUserData* data = NULL;
2787 if ( userData ) {
2788 bool blocked = wxPyBeginBlockThreads();
2789 data = new wxPyUserData(userData);
2790 wxPyEndBlockThreads(blocked);
2791 }
2792 return new wxSizerItem(window, proportion, flag, border, data);
2793 }
2794 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2795 wxPyUserData* data = NULL;
2796 if ( userData ) {
2797 bool blocked = wxPyBeginBlockThreads();
2798 data = new wxPyUserData(userData);
2799 wxPyEndBlockThreads(blocked);
2800 }
2801 return new wxSizerItem(width, height, proportion, flag, border, data);
2802 }
2803 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2804 wxPyUserData* data = NULL;
2805 if ( userData ) {
2806 bool blocked = wxPyBeginBlockThreads();
2807 data = new wxPyUserData(userData);
2808 wxPyEndBlockThreads(blocked);
2809 }
2810 return new wxSizerItem(sizer, proportion, flag, border, data);
2811 }
2812
2813 #include <float.h>
2814 SWIGINTERN int
2815 SWIG_CheckDoubleInRange(double value, double min_value,
2816 double max_value, const char* errmsg)
2817 {
2818 if (value < min_value) {
2819 if (errmsg) {
2820 PyErr_Format(PyExc_OverflowError,
2821 "value %g is less than %s minimum %g",
2822 value, errmsg, min_value);
2823 }
2824 return 0;
2825 } else if (value > max_value) {
2826 if (errmsg) {
2827 PyErr_Format(PyExc_OverflowError,
2828 "value %g is greater than %s maximum %g",
2829 value, errmsg, max_value);
2830 }
2831 return 0;
2832 }
2833 return 1;
2834 }
2835
2836
2837 SWIGINTERN int
2838 SWIG_AsVal_float(PyObject *obj, float *val)
2839 {
2840 const char* errmsg = val ? "float" : (char*)0;
2841 double v;
2842 if (SWIG_AsVal_double(obj, &v)) {
2843 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2844 if (val) *val = (float)(v);
2845 return 1;
2846 } else {
2847 return 0;
2848 }
2849 } else {
2850 PyErr_Clear();
2851 }
2852 if (val) {
2853 SWIG_type_error(errmsg, obj);
2854 }
2855 return 0;
2856 }
2857
2858
2859 SWIGINTERNSHORT float
2860 SWIG_As_float(PyObject* obj)
2861 {
2862 float v;
2863 if (!SWIG_AsVal_float(obj, &v)) {
2864 /*
2865 this is needed to make valgrind/purify happier.
2866 */
2867 memset((void*)&v, 0, sizeof(float));
2868 }
2869 return v;
2870 }
2871
2872
2873 SWIGINTERNSHORT int
2874 SWIG_Check_float(PyObject* obj)
2875 {
2876 return SWIG_AsVal_float(obj, (float*)0);
2877 }
2878
2879
2880 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2881 #define SWIG_From_float PyFloat_FromDouble
2882 /*@@*/
2883
2884 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2885 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2886 if (data) {
2887 Py_INCREF(data->m_obj);
2888 return data->m_obj;
2889 } else {
2890 Py_INCREF(Py_None);
2891 return Py_None;
2892 }
2893 }
2894
2895 // Figure out the type of the sizer item
2896
2897 struct wxPySizerItemInfo {
2898 wxPySizerItemInfo()
2899 : window(NULL), sizer(NULL), gotSize(false),
2900 size(wxDefaultSize), gotPos(false), pos(-1)
2901 {}
2902
2903 wxWindow* window;
2904 wxSizer* sizer;
2905 bool gotSize;
2906 wxSize size;
2907 bool gotPos;
2908 int pos;
2909 };
2910
2911 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2912
2913 wxPySizerItemInfo info;
2914 wxSize size;
2915 wxSize* sizePtr = &size;
2916
2917 // Find out what the type of the item is
2918 // try wxWindow
2919 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2920 PyErr_Clear();
2921 info.window = NULL;
2922
2923 // try wxSizer
2924 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2925 PyErr_Clear();
2926 info.sizer = NULL;
2927
2928 // try wxSize or (w,h)
2929 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2930 info.size = *sizePtr;
2931 info.gotSize = true;
2932 }
2933
2934 // or a single int
2935 if (checkIdx && PyInt_Check(item)) {
2936 info.pos = PyInt_AsLong(item);
2937 info.gotPos = true;
2938 }
2939 }
2940 }
2941
2942 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2943 // no expected type, figure out what kind of error message to generate
2944 if ( !checkSize && !checkIdx )
2945 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2946 else if ( checkSize && !checkIdx )
2947 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2948 else if ( !checkSize && checkIdx)
2949 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2950 else
2951 // can this one happen?
2952 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2953 }
2954
2955 return info;
2956 }
2957
2958 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2959 if (!self->GetClientObject())
2960 self->SetClientObject(new wxPyOORClientData(_self));
2961 }
2962 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2963
2964 wxPyUserData* data = NULL;
2965 bool blocked = wxPyBeginBlockThreads();
2966 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2967 if ( userData && (info.window || info.sizer || info.gotSize) )
2968 data = new wxPyUserData(userData);
2969 wxPyEndBlockThreads(blocked);
2970
2971 // Now call the real Add method if a valid item type was found
2972 if ( info.window )
2973 return self->Add(info.window, proportion, flag, border, data);
2974 else if ( info.sizer )
2975 return self->Add(info.sizer, proportion, flag, border, data);
2976 else if (info.gotSize)
2977 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
2978 proportion, flag, border, data);
2979 else
2980 return NULL;
2981 }
2982 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2983
2984 wxPyUserData* data = NULL;
2985 bool blocked = wxPyBeginBlockThreads();
2986 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2987 if ( userData && (info.window || info.sizer || info.gotSize) )
2988 data = new wxPyUserData(userData);
2989 wxPyEndBlockThreads(blocked);
2990
2991 // Now call the real Insert method if a valid item type was found
2992 if ( info.window )
2993 return self->Insert(before, info.window, proportion, flag, border, data);
2994 else if ( info.sizer )
2995 return self->Insert(before, info.sizer, proportion, flag, border, data);
2996 else if (info.gotSize)
2997 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
2998 proportion, flag, border, data);
2999 else
3000 return NULL;
3001 }
3002 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3003
3004 wxPyUserData* data = NULL;
3005 bool blocked = wxPyBeginBlockThreads();
3006 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3007 if ( userData && (info.window || info.sizer || info.gotSize) )
3008 data = new wxPyUserData(userData);
3009 wxPyEndBlockThreads(blocked);
3010
3011 // Now call the real Prepend method if a valid item type was found
3012 if ( info.window )
3013 return self->Prepend(info.window, proportion, flag, border, data);
3014 else if ( info.sizer )
3015 return self->Prepend(info.sizer, proportion, flag, border, data);
3016 else if (info.gotSize)
3017 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3018 proportion, flag, border, data);
3019 else
3020 return NULL;
3021 }
3022 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3023 bool blocked = wxPyBeginBlockThreads();
3024 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3025 wxPyEndBlockThreads(blocked);
3026 if ( info.window )
3027 return self->Remove(info.window);
3028 else if ( info.sizer )
3029 return self->Remove(info.sizer);
3030 else if ( info.gotPos )
3031 return self->Remove(info.pos);
3032 else
3033 return false;
3034 }
3035 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3036 bool blocked = wxPyBeginBlockThreads();
3037 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3038 wxPyEndBlockThreads(blocked);
3039 if ( info.window )
3040 return self->Detach(info.window);
3041 else if ( info.sizer )
3042 return self->Detach(info.sizer);
3043 else if ( info.gotPos )
3044 return self->Detach(info.pos);
3045 else
3046 return false;
3047 }
3048 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3049 bool blocked = wxPyBeginBlockThreads();
3050 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3051 wxPyEndBlockThreads(blocked);
3052 if ( info.window )
3053 return self->GetItem(info.window);
3054 else if ( info.sizer )
3055 return self->GetItem(info.sizer);
3056 else if ( info.gotPos )
3057 return self->GetItem(info.pos);
3058 else
3059 return NULL;
3060 }
3061 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3062 bool blocked = wxPyBeginBlockThreads();
3063 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3064 wxPyEndBlockThreads(blocked);
3065 if ( info.window )
3066 self->SetItemMinSize(info.window, size);
3067 else if ( info.sizer )
3068 self->SetItemMinSize(info.sizer, size);
3069 else if ( info.gotPos )
3070 self->SetItemMinSize(info.pos, size);
3071 }
3072 static PyObject *wxSizer_GetChildren(wxSizer *self){
3073 wxSizerItemList& list = self->GetChildren();
3074 return wxPy_ConvertList(&list);
3075 }
3076 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3077 bool blocked = wxPyBeginBlockThreads();
3078 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3079 wxPyEndBlockThreads(blocked);
3080 if ( info.window )
3081 return self->Show(info.window, show, recursive);
3082 else if ( info.sizer )
3083 return self->Show(info.sizer, show, recursive);
3084 else if ( info.gotPos )
3085 return self->Show(info.pos, show);
3086 else
3087 return false;
3088 }
3089 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3090 bool blocked = wxPyBeginBlockThreads();
3091 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3092 wxPyEndBlockThreads(blocked);
3093 if ( info.window )
3094 return self->IsShown(info.window);
3095 else if ( info.sizer )
3096 return self->IsShown(info.sizer);
3097 else if ( info.gotPos )
3098 return self->IsShown(info.pos);
3099 else
3100 return false;
3101 }
3102
3103 // See pyclasses.h
3104 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3105 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3106 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3107
3108
3109
3110
3111 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3112 {
3113 if (source == Py_None) {
3114 **obj = wxGBPosition(-1,-1);
3115 return true;
3116 }
3117 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3118 }
3119
3120 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3121 {
3122 if (source == Py_None) {
3123 **obj = wxGBSpan(-1,-1);
3124 return true;
3125 }
3126 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3127 }
3128
3129
3130 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3131 self->SetRow(row);
3132 self->SetCol(col);
3133 }
3134 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3135 bool blocked = wxPyBeginBlockThreads();
3136 PyObject* tup = PyTuple_New(2);
3137 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3138 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3139 wxPyEndBlockThreads(blocked);
3140 return tup;
3141 }
3142 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3143 self->SetRowspan(rowspan);
3144 self->SetColspan(colspan);
3145 }
3146 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3147 bool blocked = wxPyBeginBlockThreads();
3148 PyObject* tup = PyTuple_New(2);
3149 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3150 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3151 wxPyEndBlockThreads(blocked);
3152 return tup;
3153 }
3154 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3155 wxPyUserData* data = NULL;
3156 if ( userData ) {
3157 bool blocked = wxPyBeginBlockThreads();
3158 data = new wxPyUserData(userData);
3159 wxPyEndBlockThreads(blocked);
3160 }
3161 return new wxGBSizerItem(window, pos, span, flag, border, data);
3162 }
3163 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3164 wxPyUserData* data = NULL;
3165 if ( userData ) {
3166 bool blocked = wxPyBeginBlockThreads();
3167 data = new wxPyUserData(userData);
3168 wxPyEndBlockThreads(blocked);
3169 }
3170 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3171 }
3172 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3173 wxPyUserData* data = NULL;
3174 if ( userData ) {
3175 bool blocked = wxPyBeginBlockThreads();
3176 data = new wxPyUserData(userData);
3177 wxPyEndBlockThreads(blocked);
3178 }
3179 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3180 }
3181 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3182 int row, col;
3183 self->GetEndPos(row, col);
3184 return wxGBPosition(row, col);
3185 }
3186 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3187
3188 wxPyUserData* data = NULL;
3189 bool blocked = wxPyBeginBlockThreads();
3190 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3191 if ( userData && (info.window || info.sizer || info.gotSize) )
3192 data = new wxPyUserData(userData);
3193 wxPyEndBlockThreads(blocked);
3194
3195 // Now call the real Add method if a valid item type was found
3196 if ( info.window )
3197 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3198 else if ( info.sizer )
3199 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3200 else if (info.gotSize)
3201 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3202 pos, span, flag, border, data);
3203 return NULL;
3204 }
3205
3206
3207 #ifdef __cplusplus
3208 extern "C" {
3209 #endif
3210 static int _wrap_EmptyString_set(PyObject *) {
3211 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3212 return 1;
3213 }
3214
3215
3216 static PyObject *_wrap_EmptyString_get(void) {
3217 PyObject *pyobj;
3218
3219 {
3220 #if wxUSE_UNICODE
3221 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3222 #else
3223 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3224 #endif
3225 }
3226 return pyobj;
3227 }
3228
3229
3230 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3231 PyObject *resultobj;
3232 wxObject *arg1 = (wxObject *) 0 ;
3233 wxString result;
3234 PyObject * obj0 = 0 ;
3235 char *kwnames[] = {
3236 (char *) "self", NULL
3237 };
3238
3239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3241 if (SWIG_arg_fail(1)) SWIG_fail;
3242 {
3243 PyThreadState* __tstate = wxPyBeginAllowThreads();
3244 result = wxObject_GetClassName(arg1);
3245
3246 wxPyEndAllowThreads(__tstate);
3247 if (PyErr_Occurred()) SWIG_fail;
3248 }
3249 {
3250 #if wxUSE_UNICODE
3251 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3252 #else
3253 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3254 #endif
3255 }
3256 return resultobj;
3257 fail:
3258 return NULL;
3259 }
3260
3261
3262 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3263 PyObject *resultobj;
3264 wxObject *arg1 = (wxObject *) 0 ;
3265 PyObject * obj0 = 0 ;
3266 char *kwnames[] = {
3267 (char *) "self", NULL
3268 };
3269
3270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3272 if (SWIG_arg_fail(1)) SWIG_fail;
3273 {
3274 PyThreadState* __tstate = wxPyBeginAllowThreads();
3275 wxObject_Destroy(arg1);
3276
3277 wxPyEndAllowThreads(__tstate);
3278 if (PyErr_Occurred()) SWIG_fail;
3279 }
3280 Py_INCREF(Py_None); resultobj = Py_None;
3281 return resultobj;
3282 fail:
3283 return NULL;
3284 }
3285
3286
3287 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3288 PyObject *obj;
3289 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3290 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3291 Py_INCREF(obj);
3292 return Py_BuildValue((char *)"");
3293 }
3294 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3295 PyObject *resultobj;
3296 wxSize *arg1 = (wxSize *) 0 ;
3297 int arg2 ;
3298 PyObject * obj0 = 0 ;
3299 PyObject * obj1 = 0 ;
3300 char *kwnames[] = {
3301 (char *) "self",(char *) "x", NULL
3302 };
3303
3304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3306 if (SWIG_arg_fail(1)) SWIG_fail;
3307 {
3308 arg2 = (int)(SWIG_As_int(obj1));
3309 if (SWIG_arg_fail(2)) SWIG_fail;
3310 }
3311 if (arg1) (arg1)->x = arg2;
3312
3313 Py_INCREF(Py_None); resultobj = Py_None;
3314 return resultobj;
3315 fail:
3316 return NULL;
3317 }
3318
3319
3320 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3321 PyObject *resultobj;
3322 wxSize *arg1 = (wxSize *) 0 ;
3323 int result;
3324 PyObject * obj0 = 0 ;
3325 char *kwnames[] = {
3326 (char *) "self", NULL
3327 };
3328
3329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3331 if (SWIG_arg_fail(1)) SWIG_fail;
3332 result = (int) ((arg1)->x);
3333
3334 {
3335 resultobj = SWIG_From_int((int)(result));
3336 }
3337 return resultobj;
3338 fail:
3339 return NULL;
3340 }
3341
3342
3343 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3344 PyObject *resultobj;
3345 wxSize *arg1 = (wxSize *) 0 ;
3346 int arg2 ;
3347 PyObject * obj0 = 0 ;
3348 PyObject * obj1 = 0 ;
3349 char *kwnames[] = {
3350 (char *) "self",(char *) "y", NULL
3351 };
3352
3353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3355 if (SWIG_arg_fail(1)) SWIG_fail;
3356 {
3357 arg2 = (int)(SWIG_As_int(obj1));
3358 if (SWIG_arg_fail(2)) SWIG_fail;
3359 }
3360 if (arg1) (arg1)->y = arg2;
3361
3362 Py_INCREF(Py_None); resultobj = Py_None;
3363 return resultobj;
3364 fail:
3365 return NULL;
3366 }
3367
3368
3369 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3370 PyObject *resultobj;
3371 wxSize *arg1 = (wxSize *) 0 ;
3372 int result;
3373 PyObject * obj0 = 0 ;
3374 char *kwnames[] = {
3375 (char *) "self", NULL
3376 };
3377
3378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3380 if (SWIG_arg_fail(1)) SWIG_fail;
3381 result = (int) ((arg1)->y);
3382
3383 {
3384 resultobj = SWIG_From_int((int)(result));
3385 }
3386 return resultobj;
3387 fail:
3388 return NULL;
3389 }
3390
3391
3392 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3393 PyObject *resultobj;
3394 int arg1 = (int) 0 ;
3395 int arg2 = (int) 0 ;
3396 wxSize *result;
3397 PyObject * obj0 = 0 ;
3398 PyObject * obj1 = 0 ;
3399 char *kwnames[] = {
3400 (char *) "w",(char *) "h", NULL
3401 };
3402
3403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3404 if (obj0) {
3405 {
3406 arg1 = (int)(SWIG_As_int(obj0));
3407 if (SWIG_arg_fail(1)) SWIG_fail;
3408 }
3409 }
3410 if (obj1) {
3411 {
3412 arg2 = (int)(SWIG_As_int(obj1));
3413 if (SWIG_arg_fail(2)) SWIG_fail;
3414 }
3415 }
3416 {
3417 PyThreadState* __tstate = wxPyBeginAllowThreads();
3418 result = (wxSize *)new wxSize(arg1,arg2);
3419
3420 wxPyEndAllowThreads(__tstate);
3421 if (PyErr_Occurred()) SWIG_fail;
3422 }
3423 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3424 return resultobj;
3425 fail:
3426 return NULL;
3427 }
3428
3429
3430 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3431 PyObject *resultobj;
3432 wxSize *arg1 = (wxSize *) 0 ;
3433 PyObject * obj0 = 0 ;
3434 char *kwnames[] = {
3435 (char *) "self", NULL
3436 };
3437
3438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3440 if (SWIG_arg_fail(1)) SWIG_fail;
3441 {
3442 PyThreadState* __tstate = wxPyBeginAllowThreads();
3443 delete arg1;
3444
3445 wxPyEndAllowThreads(__tstate);
3446 if (PyErr_Occurred()) SWIG_fail;
3447 }
3448 Py_INCREF(Py_None); resultobj = Py_None;
3449 return resultobj;
3450 fail:
3451 return NULL;
3452 }
3453
3454
3455 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3456 PyObject *resultobj;
3457 wxSize *arg1 = (wxSize *) 0 ;
3458 wxSize *arg2 = 0 ;
3459 bool result;
3460 wxSize temp2 ;
3461 PyObject * obj0 = 0 ;
3462 PyObject * obj1 = 0 ;
3463 char *kwnames[] = {
3464 (char *) "self",(char *) "sz", NULL
3465 };
3466
3467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3469 if (SWIG_arg_fail(1)) SWIG_fail;
3470 {
3471 arg2 = &temp2;
3472 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3473 }
3474 {
3475 PyThreadState* __tstate = wxPyBeginAllowThreads();
3476 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3477
3478 wxPyEndAllowThreads(__tstate);
3479 if (PyErr_Occurred()) SWIG_fail;
3480 }
3481 {
3482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3483 }
3484 return resultobj;
3485 fail:
3486 return NULL;
3487 }
3488
3489
3490 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3491 PyObject *resultobj;
3492 wxSize *arg1 = (wxSize *) 0 ;
3493 wxSize *arg2 = 0 ;
3494 bool result;
3495 wxSize temp2 ;
3496 PyObject * obj0 = 0 ;
3497 PyObject * obj1 = 0 ;
3498 char *kwnames[] = {
3499 (char *) "self",(char *) "sz", NULL
3500 };
3501
3502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3504 if (SWIG_arg_fail(1)) SWIG_fail;
3505 {
3506 arg2 = &temp2;
3507 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3508 }
3509 {
3510 PyThreadState* __tstate = wxPyBeginAllowThreads();
3511 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3512
3513 wxPyEndAllowThreads(__tstate);
3514 if (PyErr_Occurred()) SWIG_fail;
3515 }
3516 {
3517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3518 }
3519 return resultobj;
3520 fail:
3521 return NULL;
3522 }
3523
3524
3525 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3526 PyObject *resultobj;
3527 wxSize *arg1 = (wxSize *) 0 ;
3528 wxSize *arg2 = 0 ;
3529 wxSize result;
3530 wxSize temp2 ;
3531 PyObject * obj0 = 0 ;
3532 PyObject * obj1 = 0 ;
3533 char *kwnames[] = {
3534 (char *) "self",(char *) "sz", NULL
3535 };
3536
3537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3539 if (SWIG_arg_fail(1)) SWIG_fail;
3540 {
3541 arg2 = &temp2;
3542 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3543 }
3544 {
3545 PyThreadState* __tstate = wxPyBeginAllowThreads();
3546 result = (arg1)->operator +((wxSize const &)*arg2);
3547
3548 wxPyEndAllowThreads(__tstate);
3549 if (PyErr_Occurred()) SWIG_fail;
3550 }
3551 {
3552 wxSize * resultptr;
3553 resultptr = new wxSize((wxSize &)(result));
3554 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3555 }
3556 return resultobj;
3557 fail:
3558 return NULL;
3559 }
3560
3561
3562 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3563 PyObject *resultobj;
3564 wxSize *arg1 = (wxSize *) 0 ;
3565 wxSize *arg2 = 0 ;
3566 wxSize result;
3567 wxSize temp2 ;
3568 PyObject * obj0 = 0 ;
3569 PyObject * obj1 = 0 ;
3570 char *kwnames[] = {
3571 (char *) "self",(char *) "sz", NULL
3572 };
3573
3574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3576 if (SWIG_arg_fail(1)) SWIG_fail;
3577 {
3578 arg2 = &temp2;
3579 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3580 }
3581 {
3582 PyThreadState* __tstate = wxPyBeginAllowThreads();
3583 result = (arg1)->operator -((wxSize const &)*arg2);
3584
3585 wxPyEndAllowThreads(__tstate);
3586 if (PyErr_Occurred()) SWIG_fail;
3587 }
3588 {
3589 wxSize * resultptr;
3590 resultptr = new wxSize((wxSize &)(result));
3591 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3592 }
3593 return resultobj;
3594 fail:
3595 return NULL;
3596 }
3597
3598
3599 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3600 PyObject *resultobj;
3601 wxSize *arg1 = (wxSize *) 0 ;
3602 wxSize *arg2 = 0 ;
3603 wxSize temp2 ;
3604 PyObject * obj0 = 0 ;
3605 PyObject * obj1 = 0 ;
3606 char *kwnames[] = {
3607 (char *) "self",(char *) "sz", NULL
3608 };
3609
3610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3612 if (SWIG_arg_fail(1)) SWIG_fail;
3613 {
3614 arg2 = &temp2;
3615 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3616 }
3617 {
3618 PyThreadState* __tstate = wxPyBeginAllowThreads();
3619 (arg1)->IncTo((wxSize const &)*arg2);
3620
3621 wxPyEndAllowThreads(__tstate);
3622 if (PyErr_Occurred()) SWIG_fail;
3623 }
3624 Py_INCREF(Py_None); resultobj = Py_None;
3625 return resultobj;
3626 fail:
3627 return NULL;
3628 }
3629
3630
3631 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3632 PyObject *resultobj;
3633 wxSize *arg1 = (wxSize *) 0 ;
3634 wxSize *arg2 = 0 ;
3635 wxSize temp2 ;
3636 PyObject * obj0 = 0 ;
3637 PyObject * obj1 = 0 ;
3638 char *kwnames[] = {
3639 (char *) "self",(char *) "sz", NULL
3640 };
3641
3642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3644 if (SWIG_arg_fail(1)) SWIG_fail;
3645 {
3646 arg2 = &temp2;
3647 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3648 }
3649 {
3650 PyThreadState* __tstate = wxPyBeginAllowThreads();
3651 (arg1)->DecTo((wxSize const &)*arg2);
3652
3653 wxPyEndAllowThreads(__tstate);
3654 if (PyErr_Occurred()) SWIG_fail;
3655 }
3656 Py_INCREF(Py_None); resultobj = Py_None;
3657 return resultobj;
3658 fail:
3659 return NULL;
3660 }
3661
3662
3663 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3664 PyObject *resultobj;
3665 wxSize *arg1 = (wxSize *) 0 ;
3666 int arg2 ;
3667 int arg3 ;
3668 PyObject * obj0 = 0 ;
3669 PyObject * obj1 = 0 ;
3670 PyObject * obj2 = 0 ;
3671 char *kwnames[] = {
3672 (char *) "self",(char *) "w",(char *) "h", NULL
3673 };
3674
3675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3677 if (SWIG_arg_fail(1)) SWIG_fail;
3678 {
3679 arg2 = (int)(SWIG_As_int(obj1));
3680 if (SWIG_arg_fail(2)) SWIG_fail;
3681 }
3682 {
3683 arg3 = (int)(SWIG_As_int(obj2));
3684 if (SWIG_arg_fail(3)) SWIG_fail;
3685 }
3686 {
3687 PyThreadState* __tstate = wxPyBeginAllowThreads();
3688 (arg1)->Set(arg2,arg3);
3689
3690 wxPyEndAllowThreads(__tstate);
3691 if (PyErr_Occurred()) SWIG_fail;
3692 }
3693 Py_INCREF(Py_None); resultobj = Py_None;
3694 return resultobj;
3695 fail:
3696 return NULL;
3697 }
3698
3699
3700 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3701 PyObject *resultobj;
3702 wxSize *arg1 = (wxSize *) 0 ;
3703 int arg2 ;
3704 PyObject * obj0 = 0 ;
3705 PyObject * obj1 = 0 ;
3706 char *kwnames[] = {
3707 (char *) "self",(char *) "w", NULL
3708 };
3709
3710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3712 if (SWIG_arg_fail(1)) SWIG_fail;
3713 {
3714 arg2 = (int)(SWIG_As_int(obj1));
3715 if (SWIG_arg_fail(2)) SWIG_fail;
3716 }
3717 {
3718 PyThreadState* __tstate = wxPyBeginAllowThreads();
3719 (arg1)->SetWidth(arg2);
3720
3721 wxPyEndAllowThreads(__tstate);
3722 if (PyErr_Occurred()) SWIG_fail;
3723 }
3724 Py_INCREF(Py_None); resultobj = Py_None;
3725 return resultobj;
3726 fail:
3727 return NULL;
3728 }
3729
3730
3731 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3732 PyObject *resultobj;
3733 wxSize *arg1 = (wxSize *) 0 ;
3734 int arg2 ;
3735 PyObject * obj0 = 0 ;
3736 PyObject * obj1 = 0 ;
3737 char *kwnames[] = {
3738 (char *) "self",(char *) "h", NULL
3739 };
3740
3741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3743 if (SWIG_arg_fail(1)) SWIG_fail;
3744 {
3745 arg2 = (int)(SWIG_As_int(obj1));
3746 if (SWIG_arg_fail(2)) SWIG_fail;
3747 }
3748 {
3749 PyThreadState* __tstate = wxPyBeginAllowThreads();
3750 (arg1)->SetHeight(arg2);
3751
3752 wxPyEndAllowThreads(__tstate);
3753 if (PyErr_Occurred()) SWIG_fail;
3754 }
3755 Py_INCREF(Py_None); resultobj = Py_None;
3756 return resultobj;
3757 fail:
3758 return NULL;
3759 }
3760
3761
3762 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3763 PyObject *resultobj;
3764 wxSize *arg1 = (wxSize *) 0 ;
3765 int result;
3766 PyObject * obj0 = 0 ;
3767 char *kwnames[] = {
3768 (char *) "self", NULL
3769 };
3770
3771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3773 if (SWIG_arg_fail(1)) SWIG_fail;
3774 {
3775 PyThreadState* __tstate = wxPyBeginAllowThreads();
3776 result = (int)((wxSize const *)arg1)->GetWidth();
3777
3778 wxPyEndAllowThreads(__tstate);
3779 if (PyErr_Occurred()) SWIG_fail;
3780 }
3781 {
3782 resultobj = SWIG_From_int((int)(result));
3783 }
3784 return resultobj;
3785 fail:
3786 return NULL;
3787 }
3788
3789
3790 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3791 PyObject *resultobj;
3792 wxSize *arg1 = (wxSize *) 0 ;
3793 int result;
3794 PyObject * obj0 = 0 ;
3795 char *kwnames[] = {
3796 (char *) "self", NULL
3797 };
3798
3799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3801 if (SWIG_arg_fail(1)) SWIG_fail;
3802 {
3803 PyThreadState* __tstate = wxPyBeginAllowThreads();
3804 result = (int)((wxSize const *)arg1)->GetHeight();
3805
3806 wxPyEndAllowThreads(__tstate);
3807 if (PyErr_Occurred()) SWIG_fail;
3808 }
3809 {
3810 resultobj = SWIG_From_int((int)(result));
3811 }
3812 return resultobj;
3813 fail:
3814 return NULL;
3815 }
3816
3817
3818 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3819 PyObject *resultobj;
3820 wxSize *arg1 = (wxSize *) 0 ;
3821 bool result;
3822 PyObject * obj0 = 0 ;
3823 char *kwnames[] = {
3824 (char *) "self", NULL
3825 };
3826
3827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3829 if (SWIG_arg_fail(1)) SWIG_fail;
3830 {
3831 PyThreadState* __tstate = wxPyBeginAllowThreads();
3832 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3833
3834 wxPyEndAllowThreads(__tstate);
3835 if (PyErr_Occurred()) SWIG_fail;
3836 }
3837 {
3838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3839 }
3840 return resultobj;
3841 fail:
3842 return NULL;
3843 }
3844
3845
3846 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3847 PyObject *resultobj;
3848 wxSize *arg1 = (wxSize *) 0 ;
3849 wxSize *arg2 = 0 ;
3850 wxSize temp2 ;
3851 PyObject * obj0 = 0 ;
3852 PyObject * obj1 = 0 ;
3853 char *kwnames[] = {
3854 (char *) "self",(char *) "size", NULL
3855 };
3856
3857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3859 if (SWIG_arg_fail(1)) SWIG_fail;
3860 {
3861 arg2 = &temp2;
3862 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3863 }
3864 {
3865 PyThreadState* __tstate = wxPyBeginAllowThreads();
3866 (arg1)->SetDefaults((wxSize const &)*arg2);
3867
3868 wxPyEndAllowThreads(__tstate);
3869 if (PyErr_Occurred()) SWIG_fail;
3870 }
3871 Py_INCREF(Py_None); resultobj = Py_None;
3872 return resultobj;
3873 fail:
3874 return NULL;
3875 }
3876
3877
3878 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3879 PyObject *resultobj;
3880 wxSize *arg1 = (wxSize *) 0 ;
3881 PyObject *result;
3882 PyObject * obj0 = 0 ;
3883 char *kwnames[] = {
3884 (char *) "self", NULL
3885 };
3886
3887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3889 if (SWIG_arg_fail(1)) SWIG_fail;
3890 {
3891 PyThreadState* __tstate = wxPyBeginAllowThreads();
3892 result = (PyObject *)wxSize_Get(arg1);
3893
3894 wxPyEndAllowThreads(__tstate);
3895 if (PyErr_Occurred()) SWIG_fail;
3896 }
3897 resultobj = result;
3898 return resultobj;
3899 fail:
3900 return NULL;
3901 }
3902
3903
3904 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3905 PyObject *obj;
3906 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3907 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3908 Py_INCREF(obj);
3909 return Py_BuildValue((char *)"");
3910 }
3911 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3912 PyObject *resultobj;
3913 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3914 double arg2 ;
3915 PyObject * obj0 = 0 ;
3916 PyObject * obj1 = 0 ;
3917 char *kwnames[] = {
3918 (char *) "self",(char *) "x", NULL
3919 };
3920
3921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3923 if (SWIG_arg_fail(1)) SWIG_fail;
3924 {
3925 arg2 = (double)(SWIG_As_double(obj1));
3926 if (SWIG_arg_fail(2)) SWIG_fail;
3927 }
3928 if (arg1) (arg1)->x = arg2;
3929
3930 Py_INCREF(Py_None); resultobj = Py_None;
3931 return resultobj;
3932 fail:
3933 return NULL;
3934 }
3935
3936
3937 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3938 PyObject *resultobj;
3939 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3940 double result;
3941 PyObject * obj0 = 0 ;
3942 char *kwnames[] = {
3943 (char *) "self", NULL
3944 };
3945
3946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3948 if (SWIG_arg_fail(1)) SWIG_fail;
3949 result = (double) ((arg1)->x);
3950
3951 {
3952 resultobj = SWIG_From_double((double)(result));
3953 }
3954 return resultobj;
3955 fail:
3956 return NULL;
3957 }
3958
3959
3960 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3961 PyObject *resultobj;
3962 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3963 double arg2 ;
3964 PyObject * obj0 = 0 ;
3965 PyObject * obj1 = 0 ;
3966 char *kwnames[] = {
3967 (char *) "self",(char *) "y", NULL
3968 };
3969
3970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3972 if (SWIG_arg_fail(1)) SWIG_fail;
3973 {
3974 arg2 = (double)(SWIG_As_double(obj1));
3975 if (SWIG_arg_fail(2)) SWIG_fail;
3976 }
3977 if (arg1) (arg1)->y = arg2;
3978
3979 Py_INCREF(Py_None); resultobj = Py_None;
3980 return resultobj;
3981 fail:
3982 return NULL;
3983 }
3984
3985
3986 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
3987 PyObject *resultobj;
3988 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3989 double result;
3990 PyObject * obj0 = 0 ;
3991 char *kwnames[] = {
3992 (char *) "self", NULL
3993 };
3994
3995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
3996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3997 if (SWIG_arg_fail(1)) SWIG_fail;
3998 result = (double) ((arg1)->y);
3999
4000 {
4001 resultobj = SWIG_From_double((double)(result));
4002 }
4003 return resultobj;
4004 fail:
4005 return NULL;
4006 }
4007
4008
4009 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4010 PyObject *resultobj;
4011 double arg1 = (double) 0.0 ;
4012 double arg2 = (double) 0.0 ;
4013 wxRealPoint *result;
4014 PyObject * obj0 = 0 ;
4015 PyObject * obj1 = 0 ;
4016 char *kwnames[] = {
4017 (char *) "x",(char *) "y", NULL
4018 };
4019
4020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4021 if (obj0) {
4022 {
4023 arg1 = (double)(SWIG_As_double(obj0));
4024 if (SWIG_arg_fail(1)) SWIG_fail;
4025 }
4026 }
4027 if (obj1) {
4028 {
4029 arg2 = (double)(SWIG_As_double(obj1));
4030 if (SWIG_arg_fail(2)) SWIG_fail;
4031 }
4032 }
4033 {
4034 PyThreadState* __tstate = wxPyBeginAllowThreads();
4035 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4036
4037 wxPyEndAllowThreads(__tstate);
4038 if (PyErr_Occurred()) SWIG_fail;
4039 }
4040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4041 return resultobj;
4042 fail:
4043 return NULL;
4044 }
4045
4046
4047 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4048 PyObject *resultobj;
4049 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4050 PyObject * obj0 = 0 ;
4051 char *kwnames[] = {
4052 (char *) "self", NULL
4053 };
4054
4055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4057 if (SWIG_arg_fail(1)) SWIG_fail;
4058 {
4059 PyThreadState* __tstate = wxPyBeginAllowThreads();
4060 delete arg1;
4061
4062 wxPyEndAllowThreads(__tstate);
4063 if (PyErr_Occurred()) SWIG_fail;
4064 }
4065 Py_INCREF(Py_None); resultobj = Py_None;
4066 return resultobj;
4067 fail:
4068 return NULL;
4069 }
4070
4071
4072 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4073 PyObject *resultobj;
4074 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4075 wxRealPoint *arg2 = 0 ;
4076 bool result;
4077 wxRealPoint temp2 ;
4078 PyObject * obj0 = 0 ;
4079 PyObject * obj1 = 0 ;
4080 char *kwnames[] = {
4081 (char *) "self",(char *) "pt", NULL
4082 };
4083
4084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4086 if (SWIG_arg_fail(1)) SWIG_fail;
4087 {
4088 arg2 = &temp2;
4089 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4090 }
4091 {
4092 PyThreadState* __tstate = wxPyBeginAllowThreads();
4093 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4094
4095 wxPyEndAllowThreads(__tstate);
4096 if (PyErr_Occurred()) SWIG_fail;
4097 }
4098 {
4099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4100 }
4101 return resultobj;
4102 fail:
4103 return NULL;
4104 }
4105
4106
4107 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4108 PyObject *resultobj;
4109 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4110 wxRealPoint *arg2 = 0 ;
4111 bool result;
4112 wxRealPoint temp2 ;
4113 PyObject * obj0 = 0 ;
4114 PyObject * obj1 = 0 ;
4115 char *kwnames[] = {
4116 (char *) "self",(char *) "pt", NULL
4117 };
4118
4119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4121 if (SWIG_arg_fail(1)) SWIG_fail;
4122 {
4123 arg2 = &temp2;
4124 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4125 }
4126 {
4127 PyThreadState* __tstate = wxPyBeginAllowThreads();
4128 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4129
4130 wxPyEndAllowThreads(__tstate);
4131 if (PyErr_Occurred()) SWIG_fail;
4132 }
4133 {
4134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4135 }
4136 return resultobj;
4137 fail:
4138 return NULL;
4139 }
4140
4141
4142 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4143 PyObject *resultobj;
4144 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4145 wxRealPoint *arg2 = 0 ;
4146 wxRealPoint result;
4147 wxRealPoint temp2 ;
4148 PyObject * obj0 = 0 ;
4149 PyObject * obj1 = 0 ;
4150 char *kwnames[] = {
4151 (char *) "self",(char *) "pt", NULL
4152 };
4153
4154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4156 if (SWIG_arg_fail(1)) SWIG_fail;
4157 {
4158 arg2 = &temp2;
4159 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4160 }
4161 {
4162 PyThreadState* __tstate = wxPyBeginAllowThreads();
4163 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4164
4165 wxPyEndAllowThreads(__tstate);
4166 if (PyErr_Occurred()) SWIG_fail;
4167 }
4168 {
4169 wxRealPoint * resultptr;
4170 resultptr = new wxRealPoint((wxRealPoint &)(result));
4171 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4172 }
4173 return resultobj;
4174 fail:
4175 return NULL;
4176 }
4177
4178
4179 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4180 PyObject *resultobj;
4181 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4182 wxRealPoint *arg2 = 0 ;
4183 wxRealPoint result;
4184 wxRealPoint temp2 ;
4185 PyObject * obj0 = 0 ;
4186 PyObject * obj1 = 0 ;
4187 char *kwnames[] = {
4188 (char *) "self",(char *) "pt", NULL
4189 };
4190
4191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4193 if (SWIG_arg_fail(1)) SWIG_fail;
4194 {
4195 arg2 = &temp2;
4196 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4197 }
4198 {
4199 PyThreadState* __tstate = wxPyBeginAllowThreads();
4200 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4201
4202 wxPyEndAllowThreads(__tstate);
4203 if (PyErr_Occurred()) SWIG_fail;
4204 }
4205 {
4206 wxRealPoint * resultptr;
4207 resultptr = new wxRealPoint((wxRealPoint &)(result));
4208 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4209 }
4210 return resultobj;
4211 fail:
4212 return NULL;
4213 }
4214
4215
4216 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4217 PyObject *resultobj;
4218 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4219 double arg2 ;
4220 double arg3 ;
4221 PyObject * obj0 = 0 ;
4222 PyObject * obj1 = 0 ;
4223 PyObject * obj2 = 0 ;
4224 char *kwnames[] = {
4225 (char *) "self",(char *) "x",(char *) "y", NULL
4226 };
4227
4228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4230 if (SWIG_arg_fail(1)) SWIG_fail;
4231 {
4232 arg2 = (double)(SWIG_As_double(obj1));
4233 if (SWIG_arg_fail(2)) SWIG_fail;
4234 }
4235 {
4236 arg3 = (double)(SWIG_As_double(obj2));
4237 if (SWIG_arg_fail(3)) SWIG_fail;
4238 }
4239 {
4240 PyThreadState* __tstate = wxPyBeginAllowThreads();
4241 wxRealPoint_Set(arg1,arg2,arg3);
4242
4243 wxPyEndAllowThreads(__tstate);
4244 if (PyErr_Occurred()) SWIG_fail;
4245 }
4246 Py_INCREF(Py_None); resultobj = Py_None;
4247 return resultobj;
4248 fail:
4249 return NULL;
4250 }
4251
4252
4253 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4254 PyObject *resultobj;
4255 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4256 PyObject *result;
4257 PyObject * obj0 = 0 ;
4258 char *kwnames[] = {
4259 (char *) "self", NULL
4260 };
4261
4262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4264 if (SWIG_arg_fail(1)) SWIG_fail;
4265 {
4266 PyThreadState* __tstate = wxPyBeginAllowThreads();
4267 result = (PyObject *)wxRealPoint_Get(arg1);
4268
4269 wxPyEndAllowThreads(__tstate);
4270 if (PyErr_Occurred()) SWIG_fail;
4271 }
4272 resultobj = result;
4273 return resultobj;
4274 fail:
4275 return NULL;
4276 }
4277
4278
4279 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4280 PyObject *obj;
4281 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4282 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4283 Py_INCREF(obj);
4284 return Py_BuildValue((char *)"");
4285 }
4286 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4287 PyObject *resultobj;
4288 wxPoint *arg1 = (wxPoint *) 0 ;
4289 int arg2 ;
4290 PyObject * obj0 = 0 ;
4291 PyObject * obj1 = 0 ;
4292 char *kwnames[] = {
4293 (char *) "self",(char *) "x", NULL
4294 };
4295
4296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4298 if (SWIG_arg_fail(1)) SWIG_fail;
4299 {
4300 arg2 = (int)(SWIG_As_int(obj1));
4301 if (SWIG_arg_fail(2)) SWIG_fail;
4302 }
4303 if (arg1) (arg1)->x = arg2;
4304
4305 Py_INCREF(Py_None); resultobj = Py_None;
4306 return resultobj;
4307 fail:
4308 return NULL;
4309 }
4310
4311
4312 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4313 PyObject *resultobj;
4314 wxPoint *arg1 = (wxPoint *) 0 ;
4315 int result;
4316 PyObject * obj0 = 0 ;
4317 char *kwnames[] = {
4318 (char *) "self", NULL
4319 };
4320
4321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4323 if (SWIG_arg_fail(1)) SWIG_fail;
4324 result = (int) ((arg1)->x);
4325
4326 {
4327 resultobj = SWIG_From_int((int)(result));
4328 }
4329 return resultobj;
4330 fail:
4331 return NULL;
4332 }
4333
4334
4335 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4336 PyObject *resultobj;
4337 wxPoint *arg1 = (wxPoint *) 0 ;
4338 int arg2 ;
4339 PyObject * obj0 = 0 ;
4340 PyObject * obj1 = 0 ;
4341 char *kwnames[] = {
4342 (char *) "self",(char *) "y", NULL
4343 };
4344
4345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4347 if (SWIG_arg_fail(1)) SWIG_fail;
4348 {
4349 arg2 = (int)(SWIG_As_int(obj1));
4350 if (SWIG_arg_fail(2)) SWIG_fail;
4351 }
4352 if (arg1) (arg1)->y = arg2;
4353
4354 Py_INCREF(Py_None); resultobj = Py_None;
4355 return resultobj;
4356 fail:
4357 return NULL;
4358 }
4359
4360
4361 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4362 PyObject *resultobj;
4363 wxPoint *arg1 = (wxPoint *) 0 ;
4364 int result;
4365 PyObject * obj0 = 0 ;
4366 char *kwnames[] = {
4367 (char *) "self", NULL
4368 };
4369
4370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4372 if (SWIG_arg_fail(1)) SWIG_fail;
4373 result = (int) ((arg1)->y);
4374
4375 {
4376 resultobj = SWIG_From_int((int)(result));
4377 }
4378 return resultobj;
4379 fail:
4380 return NULL;
4381 }
4382
4383
4384 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4385 PyObject *resultobj;
4386 int arg1 = (int) 0 ;
4387 int arg2 = (int) 0 ;
4388 wxPoint *result;
4389 PyObject * obj0 = 0 ;
4390 PyObject * obj1 = 0 ;
4391 char *kwnames[] = {
4392 (char *) "x",(char *) "y", NULL
4393 };
4394
4395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4396 if (obj0) {
4397 {
4398 arg1 = (int)(SWIG_As_int(obj0));
4399 if (SWIG_arg_fail(1)) SWIG_fail;
4400 }
4401 }
4402 if (obj1) {
4403 {
4404 arg2 = (int)(SWIG_As_int(obj1));
4405 if (SWIG_arg_fail(2)) SWIG_fail;
4406 }
4407 }
4408 {
4409 PyThreadState* __tstate = wxPyBeginAllowThreads();
4410 result = (wxPoint *)new wxPoint(arg1,arg2);
4411
4412 wxPyEndAllowThreads(__tstate);
4413 if (PyErr_Occurred()) SWIG_fail;
4414 }
4415 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4416 return resultobj;
4417 fail:
4418 return NULL;
4419 }
4420
4421
4422 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4423 PyObject *resultobj;
4424 wxPoint *arg1 = (wxPoint *) 0 ;
4425 PyObject * obj0 = 0 ;
4426 char *kwnames[] = {
4427 (char *) "self", NULL
4428 };
4429
4430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4432 if (SWIG_arg_fail(1)) SWIG_fail;
4433 {
4434 PyThreadState* __tstate = wxPyBeginAllowThreads();
4435 delete arg1;
4436
4437 wxPyEndAllowThreads(__tstate);
4438 if (PyErr_Occurred()) SWIG_fail;
4439 }
4440 Py_INCREF(Py_None); resultobj = Py_None;
4441 return resultobj;
4442 fail:
4443 return NULL;
4444 }
4445
4446
4447 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4448 PyObject *resultobj;
4449 wxPoint *arg1 = (wxPoint *) 0 ;
4450 wxPoint *arg2 = 0 ;
4451 bool result;
4452 wxPoint temp2 ;
4453 PyObject * obj0 = 0 ;
4454 PyObject * obj1 = 0 ;
4455 char *kwnames[] = {
4456 (char *) "self",(char *) "pt", NULL
4457 };
4458
4459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4461 if (SWIG_arg_fail(1)) SWIG_fail;
4462 {
4463 arg2 = &temp2;
4464 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4465 }
4466 {
4467 PyThreadState* __tstate = wxPyBeginAllowThreads();
4468 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4469
4470 wxPyEndAllowThreads(__tstate);
4471 if (PyErr_Occurred()) SWIG_fail;
4472 }
4473 {
4474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4475 }
4476 return resultobj;
4477 fail:
4478 return NULL;
4479 }
4480
4481
4482 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4483 PyObject *resultobj;
4484 wxPoint *arg1 = (wxPoint *) 0 ;
4485 wxPoint *arg2 = 0 ;
4486 bool result;
4487 wxPoint temp2 ;
4488 PyObject * obj0 = 0 ;
4489 PyObject * obj1 = 0 ;
4490 char *kwnames[] = {
4491 (char *) "self",(char *) "pt", NULL
4492 };
4493
4494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4496 if (SWIG_arg_fail(1)) SWIG_fail;
4497 {
4498 arg2 = &temp2;
4499 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4500 }
4501 {
4502 PyThreadState* __tstate = wxPyBeginAllowThreads();
4503 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4504
4505 wxPyEndAllowThreads(__tstate);
4506 if (PyErr_Occurred()) SWIG_fail;
4507 }
4508 {
4509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4510 }
4511 return resultobj;
4512 fail:
4513 return NULL;
4514 }
4515
4516
4517 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4518 PyObject *resultobj;
4519 wxPoint *arg1 = (wxPoint *) 0 ;
4520 wxPoint *arg2 = 0 ;
4521 wxPoint result;
4522 wxPoint temp2 ;
4523 PyObject * obj0 = 0 ;
4524 PyObject * obj1 = 0 ;
4525 char *kwnames[] = {
4526 (char *) "self",(char *) "pt", NULL
4527 };
4528
4529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4531 if (SWIG_arg_fail(1)) SWIG_fail;
4532 {
4533 arg2 = &temp2;
4534 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4535 }
4536 {
4537 PyThreadState* __tstate = wxPyBeginAllowThreads();
4538 result = (arg1)->operator +((wxPoint const &)*arg2);
4539
4540 wxPyEndAllowThreads(__tstate);
4541 if (PyErr_Occurred()) SWIG_fail;
4542 }
4543 {
4544 wxPoint * resultptr;
4545 resultptr = new wxPoint((wxPoint &)(result));
4546 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4547 }
4548 return resultobj;
4549 fail:
4550 return NULL;
4551 }
4552
4553
4554 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4555 PyObject *resultobj;
4556 wxPoint *arg1 = (wxPoint *) 0 ;
4557 wxPoint *arg2 = 0 ;
4558 wxPoint result;
4559 wxPoint temp2 ;
4560 PyObject * obj0 = 0 ;
4561 PyObject * obj1 = 0 ;
4562 char *kwnames[] = {
4563 (char *) "self",(char *) "pt", NULL
4564 };
4565
4566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4568 if (SWIG_arg_fail(1)) SWIG_fail;
4569 {
4570 arg2 = &temp2;
4571 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4572 }
4573 {
4574 PyThreadState* __tstate = wxPyBeginAllowThreads();
4575 result = (arg1)->operator -((wxPoint const &)*arg2);
4576
4577 wxPyEndAllowThreads(__tstate);
4578 if (PyErr_Occurred()) SWIG_fail;
4579 }
4580 {
4581 wxPoint * resultptr;
4582 resultptr = new wxPoint((wxPoint &)(result));
4583 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4584 }
4585 return resultobj;
4586 fail:
4587 return NULL;
4588 }
4589
4590
4591 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4592 PyObject *resultobj;
4593 wxPoint *arg1 = (wxPoint *) 0 ;
4594 wxPoint *arg2 = 0 ;
4595 wxPoint *result;
4596 wxPoint temp2 ;
4597 PyObject * obj0 = 0 ;
4598 PyObject * obj1 = 0 ;
4599 char *kwnames[] = {
4600 (char *) "self",(char *) "pt", NULL
4601 };
4602
4603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4605 if (SWIG_arg_fail(1)) SWIG_fail;
4606 {
4607 arg2 = &temp2;
4608 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4609 }
4610 {
4611 PyThreadState* __tstate = wxPyBeginAllowThreads();
4612 {
4613 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4614 result = (wxPoint *) &_result_ref;
4615 }
4616
4617 wxPyEndAllowThreads(__tstate);
4618 if (PyErr_Occurred()) SWIG_fail;
4619 }
4620 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4621 return resultobj;
4622 fail:
4623 return NULL;
4624 }
4625
4626
4627 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4628 PyObject *resultobj;
4629 wxPoint *arg1 = (wxPoint *) 0 ;
4630 wxPoint *arg2 = 0 ;
4631 wxPoint *result;
4632 wxPoint temp2 ;
4633 PyObject * obj0 = 0 ;
4634 PyObject * obj1 = 0 ;
4635 char *kwnames[] = {
4636 (char *) "self",(char *) "pt", NULL
4637 };
4638
4639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4641 if (SWIG_arg_fail(1)) SWIG_fail;
4642 {
4643 arg2 = &temp2;
4644 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4645 }
4646 {
4647 PyThreadState* __tstate = wxPyBeginAllowThreads();
4648 {
4649 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4650 result = (wxPoint *) &_result_ref;
4651 }
4652
4653 wxPyEndAllowThreads(__tstate);
4654 if (PyErr_Occurred()) SWIG_fail;
4655 }
4656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4657 return resultobj;
4658 fail:
4659 return NULL;
4660 }
4661
4662
4663 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4664 PyObject *resultobj;
4665 wxPoint *arg1 = (wxPoint *) 0 ;
4666 long arg2 ;
4667 long arg3 ;
4668 PyObject * obj0 = 0 ;
4669 PyObject * obj1 = 0 ;
4670 PyObject * obj2 = 0 ;
4671 char *kwnames[] = {
4672 (char *) "self",(char *) "x",(char *) "y", NULL
4673 };
4674
4675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4677 if (SWIG_arg_fail(1)) SWIG_fail;
4678 {
4679 arg2 = (long)(SWIG_As_long(obj1));
4680 if (SWIG_arg_fail(2)) SWIG_fail;
4681 }
4682 {
4683 arg3 = (long)(SWIG_As_long(obj2));
4684 if (SWIG_arg_fail(3)) SWIG_fail;
4685 }
4686 {
4687 PyThreadState* __tstate = wxPyBeginAllowThreads();
4688 wxPoint_Set(arg1,arg2,arg3);
4689
4690 wxPyEndAllowThreads(__tstate);
4691 if (PyErr_Occurred()) SWIG_fail;
4692 }
4693 Py_INCREF(Py_None); resultobj = Py_None;
4694 return resultobj;
4695 fail:
4696 return NULL;
4697 }
4698
4699
4700 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4701 PyObject *resultobj;
4702 wxPoint *arg1 = (wxPoint *) 0 ;
4703 PyObject *result;
4704 PyObject * obj0 = 0 ;
4705 char *kwnames[] = {
4706 (char *) "self", NULL
4707 };
4708
4709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4711 if (SWIG_arg_fail(1)) SWIG_fail;
4712 {
4713 PyThreadState* __tstate = wxPyBeginAllowThreads();
4714 result = (PyObject *)wxPoint_Get(arg1);
4715
4716 wxPyEndAllowThreads(__tstate);
4717 if (PyErr_Occurred()) SWIG_fail;
4718 }
4719 resultobj = result;
4720 return resultobj;
4721 fail:
4722 return NULL;
4723 }
4724
4725
4726 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4727 PyObject *obj;
4728 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4729 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4730 Py_INCREF(obj);
4731 return Py_BuildValue((char *)"");
4732 }
4733 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4734 PyObject *resultobj;
4735 int arg1 = (int) 0 ;
4736 int arg2 = (int) 0 ;
4737 int arg3 = (int) 0 ;
4738 int arg4 = (int) 0 ;
4739 wxRect *result;
4740 PyObject * obj0 = 0 ;
4741 PyObject * obj1 = 0 ;
4742 PyObject * obj2 = 0 ;
4743 PyObject * obj3 = 0 ;
4744 char *kwnames[] = {
4745 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4746 };
4747
4748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4749 if (obj0) {
4750 {
4751 arg1 = (int)(SWIG_As_int(obj0));
4752 if (SWIG_arg_fail(1)) SWIG_fail;
4753 }
4754 }
4755 if (obj1) {
4756 {
4757 arg2 = (int)(SWIG_As_int(obj1));
4758 if (SWIG_arg_fail(2)) SWIG_fail;
4759 }
4760 }
4761 if (obj2) {
4762 {
4763 arg3 = (int)(SWIG_As_int(obj2));
4764 if (SWIG_arg_fail(3)) SWIG_fail;
4765 }
4766 }
4767 if (obj3) {
4768 {
4769 arg4 = (int)(SWIG_As_int(obj3));
4770 if (SWIG_arg_fail(4)) SWIG_fail;
4771 }
4772 }
4773 {
4774 PyThreadState* __tstate = wxPyBeginAllowThreads();
4775 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4776
4777 wxPyEndAllowThreads(__tstate);
4778 if (PyErr_Occurred()) SWIG_fail;
4779 }
4780 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4781 return resultobj;
4782 fail:
4783 return NULL;
4784 }
4785
4786
4787 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4788 PyObject *resultobj;
4789 wxPoint *arg1 = 0 ;
4790 wxPoint *arg2 = 0 ;
4791 wxRect *result;
4792 wxPoint temp1 ;
4793 wxPoint temp2 ;
4794 PyObject * obj0 = 0 ;
4795 PyObject * obj1 = 0 ;
4796 char *kwnames[] = {
4797 (char *) "topLeft",(char *) "bottomRight", NULL
4798 };
4799
4800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4801 {
4802 arg1 = &temp1;
4803 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4804 }
4805 {
4806 arg2 = &temp2;
4807 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4808 }
4809 {
4810 PyThreadState* __tstate = wxPyBeginAllowThreads();
4811 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4812
4813 wxPyEndAllowThreads(__tstate);
4814 if (PyErr_Occurred()) SWIG_fail;
4815 }
4816 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4817 return resultobj;
4818 fail:
4819 return NULL;
4820 }
4821
4822
4823 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4824 PyObject *resultobj;
4825 wxPoint *arg1 = 0 ;
4826 wxSize *arg2 = 0 ;
4827 wxRect *result;
4828 wxPoint temp1 ;
4829 wxSize temp2 ;
4830 PyObject * obj0 = 0 ;
4831 PyObject * obj1 = 0 ;
4832 char *kwnames[] = {
4833 (char *) "pos",(char *) "size", NULL
4834 };
4835
4836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4837 {
4838 arg1 = &temp1;
4839 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4840 }
4841 {
4842 arg2 = &temp2;
4843 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4844 }
4845 {
4846 PyThreadState* __tstate = wxPyBeginAllowThreads();
4847 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4848
4849 wxPyEndAllowThreads(__tstate);
4850 if (PyErr_Occurred()) SWIG_fail;
4851 }
4852 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4853 return resultobj;
4854 fail:
4855 return NULL;
4856 }
4857
4858
4859 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4860 PyObject *resultobj;
4861 wxSize *arg1 = 0 ;
4862 wxRect *result;
4863 wxSize temp1 ;
4864 PyObject * obj0 = 0 ;
4865 char *kwnames[] = {
4866 (char *) "size", NULL
4867 };
4868
4869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4870 {
4871 arg1 = &temp1;
4872 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4873 }
4874 {
4875 PyThreadState* __tstate = wxPyBeginAllowThreads();
4876 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4877
4878 wxPyEndAllowThreads(__tstate);
4879 if (PyErr_Occurred()) SWIG_fail;
4880 }
4881 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4882 return resultobj;
4883 fail:
4884 return NULL;
4885 }
4886
4887
4888 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4889 PyObject *resultobj;
4890 wxRect *arg1 = (wxRect *) 0 ;
4891 PyObject * obj0 = 0 ;
4892 char *kwnames[] = {
4893 (char *) "self", NULL
4894 };
4895
4896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4898 if (SWIG_arg_fail(1)) SWIG_fail;
4899 {
4900 PyThreadState* __tstate = wxPyBeginAllowThreads();
4901 delete arg1;
4902
4903 wxPyEndAllowThreads(__tstate);
4904 if (PyErr_Occurred()) SWIG_fail;
4905 }
4906 Py_INCREF(Py_None); resultobj = Py_None;
4907 return resultobj;
4908 fail:
4909 return NULL;
4910 }
4911
4912
4913 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4914 PyObject *resultobj;
4915 wxRect *arg1 = (wxRect *) 0 ;
4916 int result;
4917 PyObject * obj0 = 0 ;
4918 char *kwnames[] = {
4919 (char *) "self", NULL
4920 };
4921
4922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4924 if (SWIG_arg_fail(1)) SWIG_fail;
4925 {
4926 PyThreadState* __tstate = wxPyBeginAllowThreads();
4927 result = (int)((wxRect const *)arg1)->GetX();
4928
4929 wxPyEndAllowThreads(__tstate);
4930 if (PyErr_Occurred()) SWIG_fail;
4931 }
4932 {
4933 resultobj = SWIG_From_int((int)(result));
4934 }
4935 return resultobj;
4936 fail:
4937 return NULL;
4938 }
4939
4940
4941 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4942 PyObject *resultobj;
4943 wxRect *arg1 = (wxRect *) 0 ;
4944 int arg2 ;
4945 PyObject * obj0 = 0 ;
4946 PyObject * obj1 = 0 ;
4947 char *kwnames[] = {
4948 (char *) "self",(char *) "x", NULL
4949 };
4950
4951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4953 if (SWIG_arg_fail(1)) SWIG_fail;
4954 {
4955 arg2 = (int)(SWIG_As_int(obj1));
4956 if (SWIG_arg_fail(2)) SWIG_fail;
4957 }
4958 {
4959 PyThreadState* __tstate = wxPyBeginAllowThreads();
4960 (arg1)->SetX(arg2);
4961
4962 wxPyEndAllowThreads(__tstate);
4963 if (PyErr_Occurred()) SWIG_fail;
4964 }
4965 Py_INCREF(Py_None); resultobj = Py_None;
4966 return resultobj;
4967 fail:
4968 return NULL;
4969 }
4970
4971
4972 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4973 PyObject *resultobj;
4974 wxRect *arg1 = (wxRect *) 0 ;
4975 int result;
4976 PyObject * obj0 = 0 ;
4977 char *kwnames[] = {
4978 (char *) "self", NULL
4979 };
4980
4981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
4982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4983 if (SWIG_arg_fail(1)) SWIG_fail;
4984 {
4985 PyThreadState* __tstate = wxPyBeginAllowThreads();
4986 result = (int)(arg1)->GetY();
4987
4988 wxPyEndAllowThreads(__tstate);
4989 if (PyErr_Occurred()) SWIG_fail;
4990 }
4991 {
4992 resultobj = SWIG_From_int((int)(result));
4993 }
4994 return resultobj;
4995 fail:
4996 return NULL;
4997 }
4998
4999
5000 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5001 PyObject *resultobj;
5002 wxRect *arg1 = (wxRect *) 0 ;
5003 int arg2 ;
5004 PyObject * obj0 = 0 ;
5005 PyObject * obj1 = 0 ;
5006 char *kwnames[] = {
5007 (char *) "self",(char *) "y", NULL
5008 };
5009
5010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5012 if (SWIG_arg_fail(1)) SWIG_fail;
5013 {
5014 arg2 = (int)(SWIG_As_int(obj1));
5015 if (SWIG_arg_fail(2)) SWIG_fail;
5016 }
5017 {
5018 PyThreadState* __tstate = wxPyBeginAllowThreads();
5019 (arg1)->SetY(arg2);
5020
5021 wxPyEndAllowThreads(__tstate);
5022 if (PyErr_Occurred()) SWIG_fail;
5023 }
5024 Py_INCREF(Py_None); resultobj = Py_None;
5025 return resultobj;
5026 fail:
5027 return NULL;
5028 }
5029
5030
5031 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5032 PyObject *resultobj;
5033 wxRect *arg1 = (wxRect *) 0 ;
5034 int result;
5035 PyObject * obj0 = 0 ;
5036 char *kwnames[] = {
5037 (char *) "self", NULL
5038 };
5039
5040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5042 if (SWIG_arg_fail(1)) SWIG_fail;
5043 {
5044 PyThreadState* __tstate = wxPyBeginAllowThreads();
5045 result = (int)((wxRect const *)arg1)->GetWidth();
5046
5047 wxPyEndAllowThreads(__tstate);
5048 if (PyErr_Occurred()) SWIG_fail;
5049 }
5050 {
5051 resultobj = SWIG_From_int((int)(result));
5052 }
5053 return resultobj;
5054 fail:
5055 return NULL;
5056 }
5057
5058
5059 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5060 PyObject *resultobj;
5061 wxRect *arg1 = (wxRect *) 0 ;
5062 int arg2 ;
5063 PyObject * obj0 = 0 ;
5064 PyObject * obj1 = 0 ;
5065 char *kwnames[] = {
5066 (char *) "self",(char *) "w", NULL
5067 };
5068
5069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5071 if (SWIG_arg_fail(1)) SWIG_fail;
5072 {
5073 arg2 = (int)(SWIG_As_int(obj1));
5074 if (SWIG_arg_fail(2)) SWIG_fail;
5075 }
5076 {
5077 PyThreadState* __tstate = wxPyBeginAllowThreads();
5078 (arg1)->SetWidth(arg2);
5079
5080 wxPyEndAllowThreads(__tstate);
5081 if (PyErr_Occurred()) SWIG_fail;
5082 }
5083 Py_INCREF(Py_None); resultobj = Py_None;
5084 return resultobj;
5085 fail:
5086 return NULL;
5087 }
5088
5089
5090 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5091 PyObject *resultobj;
5092 wxRect *arg1 = (wxRect *) 0 ;
5093 int result;
5094 PyObject * obj0 = 0 ;
5095 char *kwnames[] = {
5096 (char *) "self", NULL
5097 };
5098
5099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5101 if (SWIG_arg_fail(1)) SWIG_fail;
5102 {
5103 PyThreadState* __tstate = wxPyBeginAllowThreads();
5104 result = (int)((wxRect const *)arg1)->GetHeight();
5105
5106 wxPyEndAllowThreads(__tstate);
5107 if (PyErr_Occurred()) SWIG_fail;
5108 }
5109 {
5110 resultobj = SWIG_From_int((int)(result));
5111 }
5112 return resultobj;
5113 fail:
5114 return NULL;
5115 }
5116
5117
5118 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5119 PyObject *resultobj;
5120 wxRect *arg1 = (wxRect *) 0 ;
5121 int arg2 ;
5122 PyObject * obj0 = 0 ;
5123 PyObject * obj1 = 0 ;
5124 char *kwnames[] = {
5125 (char *) "self",(char *) "h", NULL
5126 };
5127
5128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5130 if (SWIG_arg_fail(1)) SWIG_fail;
5131 {
5132 arg2 = (int)(SWIG_As_int(obj1));
5133 if (SWIG_arg_fail(2)) SWIG_fail;
5134 }
5135 {
5136 PyThreadState* __tstate = wxPyBeginAllowThreads();
5137 (arg1)->SetHeight(arg2);
5138
5139 wxPyEndAllowThreads(__tstate);
5140 if (PyErr_Occurred()) SWIG_fail;
5141 }
5142 Py_INCREF(Py_None); resultobj = Py_None;
5143 return resultobj;
5144 fail:
5145 return NULL;
5146 }
5147
5148
5149 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5150 PyObject *resultobj;
5151 wxRect *arg1 = (wxRect *) 0 ;
5152 wxPoint result;
5153 PyObject * obj0 = 0 ;
5154 char *kwnames[] = {
5155 (char *) "self", NULL
5156 };
5157
5158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5160 if (SWIG_arg_fail(1)) SWIG_fail;
5161 {
5162 PyThreadState* __tstate = wxPyBeginAllowThreads();
5163 result = ((wxRect const *)arg1)->GetPosition();
5164
5165 wxPyEndAllowThreads(__tstate);
5166 if (PyErr_Occurred()) SWIG_fail;
5167 }
5168 {
5169 wxPoint * resultptr;
5170 resultptr = new wxPoint((wxPoint &)(result));
5171 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5172 }
5173 return resultobj;
5174 fail:
5175 return NULL;
5176 }
5177
5178
5179 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5180 PyObject *resultobj;
5181 wxRect *arg1 = (wxRect *) 0 ;
5182 wxPoint *arg2 = 0 ;
5183 wxPoint temp2 ;
5184 PyObject * obj0 = 0 ;
5185 PyObject * obj1 = 0 ;
5186 char *kwnames[] = {
5187 (char *) "self",(char *) "p", NULL
5188 };
5189
5190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5192 if (SWIG_arg_fail(1)) SWIG_fail;
5193 {
5194 arg2 = &temp2;
5195 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5196 }
5197 {
5198 PyThreadState* __tstate = wxPyBeginAllowThreads();
5199 (arg1)->SetPosition((wxPoint const &)*arg2);
5200
5201 wxPyEndAllowThreads(__tstate);
5202 if (PyErr_Occurred()) SWIG_fail;
5203 }
5204 Py_INCREF(Py_None); resultobj = Py_None;
5205 return resultobj;
5206 fail:
5207 return NULL;
5208 }
5209
5210
5211 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5212 PyObject *resultobj;
5213 wxRect *arg1 = (wxRect *) 0 ;
5214 wxSize result;
5215 PyObject * obj0 = 0 ;
5216 char *kwnames[] = {
5217 (char *) "self", NULL
5218 };
5219
5220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5222 if (SWIG_arg_fail(1)) SWIG_fail;
5223 {
5224 PyThreadState* __tstate = wxPyBeginAllowThreads();
5225 result = ((wxRect const *)arg1)->GetSize();
5226
5227 wxPyEndAllowThreads(__tstate);
5228 if (PyErr_Occurred()) SWIG_fail;
5229 }
5230 {
5231 wxSize * resultptr;
5232 resultptr = new wxSize((wxSize &)(result));
5233 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5234 }
5235 return resultobj;
5236 fail:
5237 return NULL;
5238 }
5239
5240
5241 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5242 PyObject *resultobj;
5243 wxRect *arg1 = (wxRect *) 0 ;
5244 wxSize *arg2 = 0 ;
5245 wxSize temp2 ;
5246 PyObject * obj0 = 0 ;
5247 PyObject * obj1 = 0 ;
5248 char *kwnames[] = {
5249 (char *) "self",(char *) "s", NULL
5250 };
5251
5252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5254 if (SWIG_arg_fail(1)) SWIG_fail;
5255 {
5256 arg2 = &temp2;
5257 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5258 }
5259 {
5260 PyThreadState* __tstate = wxPyBeginAllowThreads();
5261 (arg1)->SetSize((wxSize const &)*arg2);
5262
5263 wxPyEndAllowThreads(__tstate);
5264 if (PyErr_Occurred()) SWIG_fail;
5265 }
5266 Py_INCREF(Py_None); resultobj = Py_None;
5267 return resultobj;
5268 fail:
5269 return NULL;
5270 }
5271
5272
5273 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5274 PyObject *resultobj;
5275 wxRect *arg1 = (wxRect *) 0 ;
5276 wxPoint result;
5277 PyObject * obj0 = 0 ;
5278 char *kwnames[] = {
5279 (char *) "self", NULL
5280 };
5281
5282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5284 if (SWIG_arg_fail(1)) SWIG_fail;
5285 {
5286 PyThreadState* __tstate = wxPyBeginAllowThreads();
5287 result = ((wxRect const *)arg1)->GetTopLeft();
5288
5289 wxPyEndAllowThreads(__tstate);
5290 if (PyErr_Occurred()) SWIG_fail;
5291 }
5292 {
5293 wxPoint * resultptr;
5294 resultptr = new wxPoint((wxPoint &)(result));
5295 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5296 }
5297 return resultobj;
5298 fail:
5299 return NULL;
5300 }
5301
5302
5303 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5304 PyObject *resultobj;
5305 wxRect *arg1 = (wxRect *) 0 ;
5306 wxPoint *arg2 = 0 ;
5307 wxPoint temp2 ;
5308 PyObject * obj0 = 0 ;
5309 PyObject * obj1 = 0 ;
5310 char *kwnames[] = {
5311 (char *) "self",(char *) "p", NULL
5312 };
5313
5314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5316 if (SWIG_arg_fail(1)) SWIG_fail;
5317 {
5318 arg2 = &temp2;
5319 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5320 }
5321 {
5322 PyThreadState* __tstate = wxPyBeginAllowThreads();
5323 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5324
5325 wxPyEndAllowThreads(__tstate);
5326 if (PyErr_Occurred()) SWIG_fail;
5327 }
5328 Py_INCREF(Py_None); resultobj = Py_None;
5329 return resultobj;
5330 fail:
5331 return NULL;
5332 }
5333
5334
5335 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5336 PyObject *resultobj;
5337 wxRect *arg1 = (wxRect *) 0 ;
5338 wxPoint result;
5339 PyObject * obj0 = 0 ;
5340 char *kwnames[] = {
5341 (char *) "self", NULL
5342 };
5343
5344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5346 if (SWIG_arg_fail(1)) SWIG_fail;
5347 {
5348 PyThreadState* __tstate = wxPyBeginAllowThreads();
5349 result = ((wxRect const *)arg1)->GetBottomRight();
5350
5351 wxPyEndAllowThreads(__tstate);
5352 if (PyErr_Occurred()) SWIG_fail;
5353 }
5354 {
5355 wxPoint * resultptr;
5356 resultptr = new wxPoint((wxPoint &)(result));
5357 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5358 }
5359 return resultobj;
5360 fail:
5361 return NULL;
5362 }
5363
5364
5365 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5366 PyObject *resultobj;
5367 wxRect *arg1 = (wxRect *) 0 ;
5368 wxPoint *arg2 = 0 ;
5369 wxPoint temp2 ;
5370 PyObject * obj0 = 0 ;
5371 PyObject * obj1 = 0 ;
5372 char *kwnames[] = {
5373 (char *) "self",(char *) "p", NULL
5374 };
5375
5376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5378 if (SWIG_arg_fail(1)) SWIG_fail;
5379 {
5380 arg2 = &temp2;
5381 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5382 }
5383 {
5384 PyThreadState* __tstate = wxPyBeginAllowThreads();
5385 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5386
5387 wxPyEndAllowThreads(__tstate);
5388 if (PyErr_Occurred()) SWIG_fail;
5389 }
5390 Py_INCREF(Py_None); resultobj = Py_None;
5391 return resultobj;
5392 fail:
5393 return NULL;
5394 }
5395
5396
5397 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5398 PyObject *resultobj;
5399 wxRect *arg1 = (wxRect *) 0 ;
5400 int result;
5401 PyObject * obj0 = 0 ;
5402 char *kwnames[] = {
5403 (char *) "self", NULL
5404 };
5405
5406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5408 if (SWIG_arg_fail(1)) SWIG_fail;
5409 {
5410 PyThreadState* __tstate = wxPyBeginAllowThreads();
5411 result = (int)((wxRect const *)arg1)->GetLeft();
5412
5413 wxPyEndAllowThreads(__tstate);
5414 if (PyErr_Occurred()) SWIG_fail;
5415 }
5416 {
5417 resultobj = SWIG_From_int((int)(result));
5418 }
5419 return resultobj;
5420 fail:
5421 return NULL;
5422 }
5423
5424
5425 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5426 PyObject *resultobj;
5427 wxRect *arg1 = (wxRect *) 0 ;
5428 int result;
5429 PyObject * obj0 = 0 ;
5430 char *kwnames[] = {
5431 (char *) "self", NULL
5432 };
5433
5434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5436 if (SWIG_arg_fail(1)) SWIG_fail;
5437 {
5438 PyThreadState* __tstate = wxPyBeginAllowThreads();
5439 result = (int)((wxRect const *)arg1)->GetTop();
5440
5441 wxPyEndAllowThreads(__tstate);
5442 if (PyErr_Occurred()) SWIG_fail;
5443 }
5444 {
5445 resultobj = SWIG_From_int((int)(result));
5446 }
5447 return resultobj;
5448 fail:
5449 return NULL;
5450 }
5451
5452
5453 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5454 PyObject *resultobj;
5455 wxRect *arg1 = (wxRect *) 0 ;
5456 int result;
5457 PyObject * obj0 = 0 ;
5458 char *kwnames[] = {
5459 (char *) "self", NULL
5460 };
5461
5462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5464 if (SWIG_arg_fail(1)) SWIG_fail;
5465 {
5466 PyThreadState* __tstate = wxPyBeginAllowThreads();
5467 result = (int)((wxRect const *)arg1)->GetBottom();
5468
5469 wxPyEndAllowThreads(__tstate);
5470 if (PyErr_Occurred()) SWIG_fail;
5471 }
5472 {
5473 resultobj = SWIG_From_int((int)(result));
5474 }
5475 return resultobj;
5476 fail:
5477 return NULL;
5478 }
5479
5480
5481 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5482 PyObject *resultobj;
5483 wxRect *arg1 = (wxRect *) 0 ;
5484 int result;
5485 PyObject * obj0 = 0 ;
5486 char *kwnames[] = {
5487 (char *) "self", NULL
5488 };
5489
5490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5492 if (SWIG_arg_fail(1)) SWIG_fail;
5493 {
5494 PyThreadState* __tstate = wxPyBeginAllowThreads();
5495 result = (int)((wxRect const *)arg1)->GetRight();
5496
5497 wxPyEndAllowThreads(__tstate);
5498 if (PyErr_Occurred()) SWIG_fail;
5499 }
5500 {
5501 resultobj = SWIG_From_int((int)(result));
5502 }
5503 return resultobj;
5504 fail:
5505 return NULL;
5506 }
5507
5508
5509 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5510 PyObject *resultobj;
5511 wxRect *arg1 = (wxRect *) 0 ;
5512 int arg2 ;
5513 PyObject * obj0 = 0 ;
5514 PyObject * obj1 = 0 ;
5515 char *kwnames[] = {
5516 (char *) "self",(char *) "left", NULL
5517 };
5518
5519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5521 if (SWIG_arg_fail(1)) SWIG_fail;
5522 {
5523 arg2 = (int)(SWIG_As_int(obj1));
5524 if (SWIG_arg_fail(2)) SWIG_fail;
5525 }
5526 {
5527 PyThreadState* __tstate = wxPyBeginAllowThreads();
5528 (arg1)->SetLeft(arg2);
5529
5530 wxPyEndAllowThreads(__tstate);
5531 if (PyErr_Occurred()) SWIG_fail;
5532 }
5533 Py_INCREF(Py_None); resultobj = Py_None;
5534 return resultobj;
5535 fail:
5536 return NULL;
5537 }
5538
5539
5540 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5541 PyObject *resultobj;
5542 wxRect *arg1 = (wxRect *) 0 ;
5543 int arg2 ;
5544 PyObject * obj0 = 0 ;
5545 PyObject * obj1 = 0 ;
5546 char *kwnames[] = {
5547 (char *) "self",(char *) "right", NULL
5548 };
5549
5550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5552 if (SWIG_arg_fail(1)) SWIG_fail;
5553 {
5554 arg2 = (int)(SWIG_As_int(obj1));
5555 if (SWIG_arg_fail(2)) SWIG_fail;
5556 }
5557 {
5558 PyThreadState* __tstate = wxPyBeginAllowThreads();
5559 (arg1)->SetRight(arg2);
5560
5561 wxPyEndAllowThreads(__tstate);
5562 if (PyErr_Occurred()) SWIG_fail;
5563 }
5564 Py_INCREF(Py_None); resultobj = Py_None;
5565 return resultobj;
5566 fail:
5567 return NULL;
5568 }
5569
5570
5571 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5572 PyObject *resultobj;
5573 wxRect *arg1 = (wxRect *) 0 ;
5574 int arg2 ;
5575 PyObject * obj0 = 0 ;
5576 PyObject * obj1 = 0 ;
5577 char *kwnames[] = {
5578 (char *) "self",(char *) "top", NULL
5579 };
5580
5581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5583 if (SWIG_arg_fail(1)) SWIG_fail;
5584 {
5585 arg2 = (int)(SWIG_As_int(obj1));
5586 if (SWIG_arg_fail(2)) SWIG_fail;
5587 }
5588 {
5589 PyThreadState* __tstate = wxPyBeginAllowThreads();
5590 (arg1)->SetTop(arg2);
5591
5592 wxPyEndAllowThreads(__tstate);
5593 if (PyErr_Occurred()) SWIG_fail;
5594 }
5595 Py_INCREF(Py_None); resultobj = Py_None;
5596 return resultobj;
5597 fail:
5598 return NULL;
5599 }
5600
5601
5602 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5603 PyObject *resultobj;
5604 wxRect *arg1 = (wxRect *) 0 ;
5605 int arg2 ;
5606 PyObject * obj0 = 0 ;
5607 PyObject * obj1 = 0 ;
5608 char *kwnames[] = {
5609 (char *) "self",(char *) "bottom", NULL
5610 };
5611
5612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5614 if (SWIG_arg_fail(1)) SWIG_fail;
5615 {
5616 arg2 = (int)(SWIG_As_int(obj1));
5617 if (SWIG_arg_fail(2)) SWIG_fail;
5618 }
5619 {
5620 PyThreadState* __tstate = wxPyBeginAllowThreads();
5621 (arg1)->SetBottom(arg2);
5622
5623 wxPyEndAllowThreads(__tstate);
5624 if (PyErr_Occurred()) SWIG_fail;
5625 }
5626 Py_INCREF(Py_None); resultobj = Py_None;
5627 return resultobj;
5628 fail:
5629 return NULL;
5630 }
5631
5632
5633 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5634 PyObject *resultobj;
5635 wxRect *arg1 = (wxRect *) 0 ;
5636 int arg2 ;
5637 int arg3 ;
5638 wxRect *result;
5639 PyObject * obj0 = 0 ;
5640 PyObject * obj1 = 0 ;
5641 PyObject * obj2 = 0 ;
5642 char *kwnames[] = {
5643 (char *) "self",(char *) "dx",(char *) "dy", NULL
5644 };
5645
5646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5648 if (SWIG_arg_fail(1)) SWIG_fail;
5649 {
5650 arg2 = (int)(SWIG_As_int(obj1));
5651 if (SWIG_arg_fail(2)) SWIG_fail;
5652 }
5653 {
5654 arg3 = (int)(SWIG_As_int(obj2));
5655 if (SWIG_arg_fail(3)) SWIG_fail;
5656 }
5657 {
5658 PyThreadState* __tstate = wxPyBeginAllowThreads();
5659 {
5660 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5661 result = (wxRect *) &_result_ref;
5662 }
5663
5664 wxPyEndAllowThreads(__tstate);
5665 if (PyErr_Occurred()) SWIG_fail;
5666 }
5667 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5668 return resultobj;
5669 fail:
5670 return NULL;
5671 }
5672
5673
5674 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5675 PyObject *resultobj;
5676 wxRect *arg1 = (wxRect *) 0 ;
5677 int arg2 ;
5678 int arg3 ;
5679 wxRect *result;
5680 PyObject * obj0 = 0 ;
5681 PyObject * obj1 = 0 ;
5682 PyObject * obj2 = 0 ;
5683 char *kwnames[] = {
5684 (char *) "self",(char *) "dx",(char *) "dy", NULL
5685 };
5686
5687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5689 if (SWIG_arg_fail(1)) SWIG_fail;
5690 {
5691 arg2 = (int)(SWIG_As_int(obj1));
5692 if (SWIG_arg_fail(2)) SWIG_fail;
5693 }
5694 {
5695 arg3 = (int)(SWIG_As_int(obj2));
5696 if (SWIG_arg_fail(3)) SWIG_fail;
5697 }
5698 {
5699 PyThreadState* __tstate = wxPyBeginAllowThreads();
5700 {
5701 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5702 result = (wxRect *) &_result_ref;
5703 }
5704
5705 wxPyEndAllowThreads(__tstate);
5706 if (PyErr_Occurred()) SWIG_fail;
5707 }
5708 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5709 return resultobj;
5710 fail:
5711 return NULL;
5712 }
5713
5714
5715 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5716 PyObject *resultobj;
5717 wxRect *arg1 = (wxRect *) 0 ;
5718 int arg2 ;
5719 int arg3 ;
5720 PyObject * obj0 = 0 ;
5721 PyObject * obj1 = 0 ;
5722 PyObject * obj2 = 0 ;
5723 char *kwnames[] = {
5724 (char *) "self",(char *) "dx",(char *) "dy", NULL
5725 };
5726
5727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5729 if (SWIG_arg_fail(1)) SWIG_fail;
5730 {
5731 arg2 = (int)(SWIG_As_int(obj1));
5732 if (SWIG_arg_fail(2)) SWIG_fail;
5733 }
5734 {
5735 arg3 = (int)(SWIG_As_int(obj2));
5736 if (SWIG_arg_fail(3)) SWIG_fail;
5737 }
5738 {
5739 PyThreadState* __tstate = wxPyBeginAllowThreads();
5740 (arg1)->Offset(arg2,arg3);
5741
5742 wxPyEndAllowThreads(__tstate);
5743 if (PyErr_Occurred()) SWIG_fail;
5744 }
5745 Py_INCREF(Py_None); resultobj = Py_None;
5746 return resultobj;
5747 fail:
5748 return NULL;
5749 }
5750
5751
5752 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5753 PyObject *resultobj;
5754 wxRect *arg1 = (wxRect *) 0 ;
5755 wxPoint *arg2 = 0 ;
5756 wxPoint temp2 ;
5757 PyObject * obj0 = 0 ;
5758 PyObject * obj1 = 0 ;
5759 char *kwnames[] = {
5760 (char *) "self",(char *) "pt", NULL
5761 };
5762
5763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5765 if (SWIG_arg_fail(1)) SWIG_fail;
5766 {
5767 arg2 = &temp2;
5768 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5769 }
5770 {
5771 PyThreadState* __tstate = wxPyBeginAllowThreads();
5772 (arg1)->Offset((wxPoint const &)*arg2);
5773
5774 wxPyEndAllowThreads(__tstate);
5775 if (PyErr_Occurred()) SWIG_fail;
5776 }
5777 Py_INCREF(Py_None); resultobj = Py_None;
5778 return resultobj;
5779 fail:
5780 return NULL;
5781 }
5782
5783
5784 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5785 PyObject *resultobj;
5786 wxRect *arg1 = (wxRect *) 0 ;
5787 wxRect *arg2 = 0 ;
5788 wxRect result;
5789 wxRect temp2 ;
5790 PyObject * obj0 = 0 ;
5791 PyObject * obj1 = 0 ;
5792 char *kwnames[] = {
5793 (char *) "self",(char *) "rect", NULL
5794 };
5795
5796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5798 if (SWIG_arg_fail(1)) SWIG_fail;
5799 {
5800 arg2 = &temp2;
5801 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5802 }
5803 {
5804 PyThreadState* __tstate = wxPyBeginAllowThreads();
5805 result = (arg1)->Intersect((wxRect const &)*arg2);
5806
5807 wxPyEndAllowThreads(__tstate);
5808 if (PyErr_Occurred()) SWIG_fail;
5809 }
5810 {
5811 wxRect * resultptr;
5812 resultptr = new wxRect((wxRect &)(result));
5813 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5814 }
5815 return resultobj;
5816 fail:
5817 return NULL;
5818 }
5819
5820
5821 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5822 PyObject *resultobj;
5823 wxRect *arg1 = (wxRect *) 0 ;
5824 wxRect *arg2 = 0 ;
5825 wxRect result;
5826 wxRect temp2 ;
5827 PyObject * obj0 = 0 ;
5828 PyObject * obj1 = 0 ;
5829 char *kwnames[] = {
5830 (char *) "self",(char *) "rect", NULL
5831 };
5832
5833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5835 if (SWIG_arg_fail(1)) SWIG_fail;
5836 {
5837 arg2 = &temp2;
5838 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5839 }
5840 {
5841 PyThreadState* __tstate = wxPyBeginAllowThreads();
5842 result = (arg1)->Union((wxRect const &)*arg2);
5843
5844 wxPyEndAllowThreads(__tstate);
5845 if (PyErr_Occurred()) SWIG_fail;
5846 }
5847 {
5848 wxRect * resultptr;
5849 resultptr = new wxRect((wxRect &)(result));
5850 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5851 }
5852 return resultobj;
5853 fail:
5854 return NULL;
5855 }
5856
5857
5858 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5859 PyObject *resultobj;
5860 wxRect *arg1 = (wxRect *) 0 ;
5861 wxRect *arg2 = 0 ;
5862 wxRect result;
5863 wxRect temp2 ;
5864 PyObject * obj0 = 0 ;
5865 PyObject * obj1 = 0 ;
5866 char *kwnames[] = {
5867 (char *) "self",(char *) "rect", NULL
5868 };
5869
5870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5872 if (SWIG_arg_fail(1)) SWIG_fail;
5873 {
5874 arg2 = &temp2;
5875 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5876 }
5877 {
5878 PyThreadState* __tstate = wxPyBeginAllowThreads();
5879 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5880
5881 wxPyEndAllowThreads(__tstate);
5882 if (PyErr_Occurred()) SWIG_fail;
5883 }
5884 {
5885 wxRect * resultptr;
5886 resultptr = new wxRect((wxRect &)(result));
5887 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5888 }
5889 return resultobj;
5890 fail:
5891 return NULL;
5892 }
5893
5894
5895 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5896 PyObject *resultobj;
5897 wxRect *arg1 = (wxRect *) 0 ;
5898 wxRect *arg2 = 0 ;
5899 wxRect *result;
5900 wxRect temp2 ;
5901 PyObject * obj0 = 0 ;
5902 PyObject * obj1 = 0 ;
5903 char *kwnames[] = {
5904 (char *) "self",(char *) "rect", NULL
5905 };
5906
5907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5909 if (SWIG_arg_fail(1)) SWIG_fail;
5910 {
5911 arg2 = &temp2;
5912 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5913 }
5914 {
5915 PyThreadState* __tstate = wxPyBeginAllowThreads();
5916 {
5917 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5918 result = (wxRect *) &_result_ref;
5919 }
5920
5921 wxPyEndAllowThreads(__tstate);
5922 if (PyErr_Occurred()) SWIG_fail;
5923 }
5924 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5925 return resultobj;
5926 fail:
5927 return NULL;
5928 }
5929
5930
5931 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5932 PyObject *resultobj;
5933 wxRect *arg1 = (wxRect *) 0 ;
5934 wxRect *arg2 = 0 ;
5935 bool result;
5936 wxRect temp2 ;
5937 PyObject * obj0 = 0 ;
5938 PyObject * obj1 = 0 ;
5939 char *kwnames[] = {
5940 (char *) "self",(char *) "rect", NULL
5941 };
5942
5943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5945 if (SWIG_arg_fail(1)) SWIG_fail;
5946 {
5947 arg2 = &temp2;
5948 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5949 }
5950 {
5951 PyThreadState* __tstate = wxPyBeginAllowThreads();
5952 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5953
5954 wxPyEndAllowThreads(__tstate);
5955 if (PyErr_Occurred()) SWIG_fail;
5956 }
5957 {
5958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5959 }
5960 return resultobj;
5961 fail:
5962 return NULL;
5963 }
5964
5965
5966 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5967 PyObject *resultobj;
5968 wxRect *arg1 = (wxRect *) 0 ;
5969 wxRect *arg2 = 0 ;
5970 bool result;
5971 wxRect temp2 ;
5972 PyObject * obj0 = 0 ;
5973 PyObject * obj1 = 0 ;
5974 char *kwnames[] = {
5975 (char *) "self",(char *) "rect", NULL
5976 };
5977
5978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
5979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5980 if (SWIG_arg_fail(1)) SWIG_fail;
5981 {
5982 arg2 = &temp2;
5983 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5984 }
5985 {
5986 PyThreadState* __tstate = wxPyBeginAllowThreads();
5987 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
5988
5989 wxPyEndAllowThreads(__tstate);
5990 if (PyErr_Occurred()) SWIG_fail;
5991 }
5992 {
5993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5994 }
5995 return resultobj;
5996 fail:
5997 return NULL;
5998 }
5999
6000
6001 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6002 PyObject *resultobj;
6003 wxRect *arg1 = (wxRect *) 0 ;
6004 int arg2 ;
6005 int arg3 ;
6006 bool result;
6007 PyObject * obj0 = 0 ;
6008 PyObject * obj1 = 0 ;
6009 PyObject * obj2 = 0 ;
6010 char *kwnames[] = {
6011 (char *) "self",(char *) "x",(char *) "y", NULL
6012 };
6013
6014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6016 if (SWIG_arg_fail(1)) SWIG_fail;
6017 {
6018 arg2 = (int)(SWIG_As_int(obj1));
6019 if (SWIG_arg_fail(2)) SWIG_fail;
6020 }
6021 {
6022 arg3 = (int)(SWIG_As_int(obj2));
6023 if (SWIG_arg_fail(3)) SWIG_fail;
6024 }
6025 {
6026 PyThreadState* __tstate = wxPyBeginAllowThreads();
6027 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6028
6029 wxPyEndAllowThreads(__tstate);
6030 if (PyErr_Occurred()) SWIG_fail;
6031 }
6032 {
6033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6034 }
6035 return resultobj;
6036 fail:
6037 return NULL;
6038 }
6039
6040
6041 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6042 PyObject *resultobj;
6043 wxRect *arg1 = (wxRect *) 0 ;
6044 wxPoint *arg2 = 0 ;
6045 bool result;
6046 wxPoint temp2 ;
6047 PyObject * obj0 = 0 ;
6048 PyObject * obj1 = 0 ;
6049 char *kwnames[] = {
6050 (char *) "self",(char *) "pt", NULL
6051 };
6052
6053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6055 if (SWIG_arg_fail(1)) SWIG_fail;
6056 {
6057 arg2 = &temp2;
6058 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6059 }
6060 {
6061 PyThreadState* __tstate = wxPyBeginAllowThreads();
6062 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6063
6064 wxPyEndAllowThreads(__tstate);
6065 if (PyErr_Occurred()) SWIG_fail;
6066 }
6067 {
6068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6069 }
6070 return resultobj;
6071 fail:
6072 return NULL;
6073 }
6074
6075
6076 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6077 PyObject *resultobj;
6078 wxRect *arg1 = (wxRect *) 0 ;
6079 wxRect *arg2 = 0 ;
6080 bool result;
6081 wxRect temp2 ;
6082 PyObject * obj0 = 0 ;
6083 PyObject * obj1 = 0 ;
6084 char *kwnames[] = {
6085 (char *) "self",(char *) "rect", NULL
6086 };
6087
6088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6090 if (SWIG_arg_fail(1)) SWIG_fail;
6091 {
6092 arg2 = &temp2;
6093 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6094 }
6095 {
6096 PyThreadState* __tstate = wxPyBeginAllowThreads();
6097 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6098
6099 wxPyEndAllowThreads(__tstate);
6100 if (PyErr_Occurred()) SWIG_fail;
6101 }
6102 {
6103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6104 }
6105 return resultobj;
6106 fail:
6107 return NULL;
6108 }
6109
6110
6111 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6112 PyObject *resultobj;
6113 wxRect *arg1 = (wxRect *) 0 ;
6114 int arg2 ;
6115 PyObject * obj0 = 0 ;
6116 PyObject * obj1 = 0 ;
6117 char *kwnames[] = {
6118 (char *) "self",(char *) "x", NULL
6119 };
6120
6121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6123 if (SWIG_arg_fail(1)) SWIG_fail;
6124 {
6125 arg2 = (int)(SWIG_As_int(obj1));
6126 if (SWIG_arg_fail(2)) SWIG_fail;
6127 }
6128 if (arg1) (arg1)->x = arg2;
6129
6130 Py_INCREF(Py_None); resultobj = Py_None;
6131 return resultobj;
6132 fail:
6133 return NULL;
6134 }
6135
6136
6137 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6138 PyObject *resultobj;
6139 wxRect *arg1 = (wxRect *) 0 ;
6140 int result;
6141 PyObject * obj0 = 0 ;
6142 char *kwnames[] = {
6143 (char *) "self", NULL
6144 };
6145
6146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6148 if (SWIG_arg_fail(1)) SWIG_fail;
6149 result = (int) ((arg1)->x);
6150
6151 {
6152 resultobj = SWIG_From_int((int)(result));
6153 }
6154 return resultobj;
6155 fail:
6156 return NULL;
6157 }
6158
6159
6160 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6161 PyObject *resultobj;
6162 wxRect *arg1 = (wxRect *) 0 ;
6163 int arg2 ;
6164 PyObject * obj0 = 0 ;
6165 PyObject * obj1 = 0 ;
6166 char *kwnames[] = {
6167 (char *) "self",(char *) "y", NULL
6168 };
6169
6170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6172 if (SWIG_arg_fail(1)) SWIG_fail;
6173 {
6174 arg2 = (int)(SWIG_As_int(obj1));
6175 if (SWIG_arg_fail(2)) SWIG_fail;
6176 }
6177 if (arg1) (arg1)->y = arg2;
6178
6179 Py_INCREF(Py_None); resultobj = Py_None;
6180 return resultobj;
6181 fail:
6182 return NULL;
6183 }
6184
6185
6186 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6187 PyObject *resultobj;
6188 wxRect *arg1 = (wxRect *) 0 ;
6189 int result;
6190 PyObject * obj0 = 0 ;
6191 char *kwnames[] = {
6192 (char *) "self", NULL
6193 };
6194
6195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6197 if (SWIG_arg_fail(1)) SWIG_fail;
6198 result = (int) ((arg1)->y);
6199
6200 {
6201 resultobj = SWIG_From_int((int)(result));
6202 }
6203 return resultobj;
6204 fail:
6205 return NULL;
6206 }
6207
6208
6209 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6210 PyObject *resultobj;
6211 wxRect *arg1 = (wxRect *) 0 ;
6212 int arg2 ;
6213 PyObject * obj0 = 0 ;
6214 PyObject * obj1 = 0 ;
6215 char *kwnames[] = {
6216 (char *) "self",(char *) "width", NULL
6217 };
6218
6219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6221 if (SWIG_arg_fail(1)) SWIG_fail;
6222 {
6223 arg2 = (int)(SWIG_As_int(obj1));
6224 if (SWIG_arg_fail(2)) SWIG_fail;
6225 }
6226 if (arg1) (arg1)->width = arg2;
6227
6228 Py_INCREF(Py_None); resultobj = Py_None;
6229 return resultobj;
6230 fail:
6231 return NULL;
6232 }
6233
6234
6235 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6236 PyObject *resultobj;
6237 wxRect *arg1 = (wxRect *) 0 ;
6238 int result;
6239 PyObject * obj0 = 0 ;
6240 char *kwnames[] = {
6241 (char *) "self", NULL
6242 };
6243
6244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6246 if (SWIG_arg_fail(1)) SWIG_fail;
6247 result = (int) ((arg1)->width);
6248
6249 {
6250 resultobj = SWIG_From_int((int)(result));
6251 }
6252 return resultobj;
6253 fail:
6254 return NULL;
6255 }
6256
6257
6258 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6259 PyObject *resultobj;
6260 wxRect *arg1 = (wxRect *) 0 ;
6261 int arg2 ;
6262 PyObject * obj0 = 0 ;
6263 PyObject * obj1 = 0 ;
6264 char *kwnames[] = {
6265 (char *) "self",(char *) "height", NULL
6266 };
6267
6268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6270 if (SWIG_arg_fail(1)) SWIG_fail;
6271 {
6272 arg2 = (int)(SWIG_As_int(obj1));
6273 if (SWIG_arg_fail(2)) SWIG_fail;
6274 }
6275 if (arg1) (arg1)->height = arg2;
6276
6277 Py_INCREF(Py_None); resultobj = Py_None;
6278 return resultobj;
6279 fail:
6280 return NULL;
6281 }
6282
6283
6284 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6285 PyObject *resultobj;
6286 wxRect *arg1 = (wxRect *) 0 ;
6287 int result;
6288 PyObject * obj0 = 0 ;
6289 char *kwnames[] = {
6290 (char *) "self", NULL
6291 };
6292
6293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6295 if (SWIG_arg_fail(1)) SWIG_fail;
6296 result = (int) ((arg1)->height);
6297
6298 {
6299 resultobj = SWIG_From_int((int)(result));
6300 }
6301 return resultobj;
6302 fail:
6303 return NULL;
6304 }
6305
6306
6307 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6308 PyObject *resultobj;
6309 wxRect *arg1 = (wxRect *) 0 ;
6310 int arg2 = (int) 0 ;
6311 int arg3 = (int) 0 ;
6312 int arg4 = (int) 0 ;
6313 int arg5 = (int) 0 ;
6314 PyObject * obj0 = 0 ;
6315 PyObject * obj1 = 0 ;
6316 PyObject * obj2 = 0 ;
6317 PyObject * obj3 = 0 ;
6318 PyObject * obj4 = 0 ;
6319 char *kwnames[] = {
6320 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6321 };
6322
6323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6325 if (SWIG_arg_fail(1)) SWIG_fail;
6326 if (obj1) {
6327 {
6328 arg2 = (int)(SWIG_As_int(obj1));
6329 if (SWIG_arg_fail(2)) SWIG_fail;
6330 }
6331 }
6332 if (obj2) {
6333 {
6334 arg3 = (int)(SWIG_As_int(obj2));
6335 if (SWIG_arg_fail(3)) SWIG_fail;
6336 }
6337 }
6338 if (obj3) {
6339 {
6340 arg4 = (int)(SWIG_As_int(obj3));
6341 if (SWIG_arg_fail(4)) SWIG_fail;
6342 }
6343 }
6344 if (obj4) {
6345 {
6346 arg5 = (int)(SWIG_As_int(obj4));
6347 if (SWIG_arg_fail(5)) SWIG_fail;
6348 }
6349 }
6350 {
6351 PyThreadState* __tstate = wxPyBeginAllowThreads();
6352 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6353
6354 wxPyEndAllowThreads(__tstate);
6355 if (PyErr_Occurred()) SWIG_fail;
6356 }
6357 Py_INCREF(Py_None); resultobj = Py_None;
6358 return resultobj;
6359 fail:
6360 return NULL;
6361 }
6362
6363
6364 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6365 PyObject *resultobj;
6366 wxRect *arg1 = (wxRect *) 0 ;
6367 PyObject *result;
6368 PyObject * obj0 = 0 ;
6369 char *kwnames[] = {
6370 (char *) "self", NULL
6371 };
6372
6373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6375 if (SWIG_arg_fail(1)) SWIG_fail;
6376 {
6377 PyThreadState* __tstate = wxPyBeginAllowThreads();
6378 result = (PyObject *)wxRect_Get(arg1);
6379
6380 wxPyEndAllowThreads(__tstate);
6381 if (PyErr_Occurred()) SWIG_fail;
6382 }
6383 resultobj = result;
6384 return resultobj;
6385 fail:
6386 return NULL;
6387 }
6388
6389
6390 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6391 PyObject *obj;
6392 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6393 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6394 Py_INCREF(obj);
6395 return Py_BuildValue((char *)"");
6396 }
6397 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6398 PyObject *resultobj;
6399 wxRect *arg1 = (wxRect *) 0 ;
6400 wxRect *arg2 = (wxRect *) 0 ;
6401 PyObject *result;
6402 PyObject * obj0 = 0 ;
6403 PyObject * obj1 = 0 ;
6404 char *kwnames[] = {
6405 (char *) "r1",(char *) "r2", NULL
6406 };
6407
6408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6410 if (SWIG_arg_fail(1)) SWIG_fail;
6411 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6412 if (SWIG_arg_fail(2)) SWIG_fail;
6413 {
6414 if (!wxPyCheckForApp()) SWIG_fail;
6415 PyThreadState* __tstate = wxPyBeginAllowThreads();
6416 result = (PyObject *)wxIntersectRect(arg1,arg2);
6417
6418 wxPyEndAllowThreads(__tstate);
6419 if (PyErr_Occurred()) SWIG_fail;
6420 }
6421 resultobj = result;
6422 return resultobj;
6423 fail:
6424 return NULL;
6425 }
6426
6427
6428 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6429 PyObject *resultobj;
6430 double arg1 = (double) 0.0 ;
6431 double arg2 = (double) 0.0 ;
6432 wxPoint2D *result;
6433 PyObject * obj0 = 0 ;
6434 PyObject * obj1 = 0 ;
6435 char *kwnames[] = {
6436 (char *) "x",(char *) "y", NULL
6437 };
6438
6439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6440 if (obj0) {
6441 {
6442 arg1 = (double)(SWIG_As_double(obj0));
6443 if (SWIG_arg_fail(1)) SWIG_fail;
6444 }
6445 }
6446 if (obj1) {
6447 {
6448 arg2 = (double)(SWIG_As_double(obj1));
6449 if (SWIG_arg_fail(2)) SWIG_fail;
6450 }
6451 }
6452 {
6453 PyThreadState* __tstate = wxPyBeginAllowThreads();
6454 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6455
6456 wxPyEndAllowThreads(__tstate);
6457 if (PyErr_Occurred()) SWIG_fail;
6458 }
6459 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6460 return resultobj;
6461 fail:
6462 return NULL;
6463 }
6464
6465
6466 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6467 PyObject *resultobj;
6468 wxPoint2D *arg1 = 0 ;
6469 wxPoint2D *result;
6470 wxPoint2D temp1 ;
6471 PyObject * obj0 = 0 ;
6472 char *kwnames[] = {
6473 (char *) "pt", NULL
6474 };
6475
6476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6477 {
6478 arg1 = &temp1;
6479 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6480 }
6481 {
6482 PyThreadState* __tstate = wxPyBeginAllowThreads();
6483 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6484
6485 wxPyEndAllowThreads(__tstate);
6486 if (PyErr_Occurred()) SWIG_fail;
6487 }
6488 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6489 return resultobj;
6490 fail:
6491 return NULL;
6492 }
6493
6494
6495 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6496 PyObject *resultobj;
6497 wxPoint *arg1 = 0 ;
6498 wxPoint2D *result;
6499 wxPoint temp1 ;
6500 PyObject * obj0 = 0 ;
6501 char *kwnames[] = {
6502 (char *) "pt", NULL
6503 };
6504
6505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6506 {
6507 arg1 = &temp1;
6508 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6509 }
6510 {
6511 PyThreadState* __tstate = wxPyBeginAllowThreads();
6512 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6513
6514 wxPyEndAllowThreads(__tstate);
6515 if (PyErr_Occurred()) SWIG_fail;
6516 }
6517 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6518 return resultobj;
6519 fail:
6520 return NULL;
6521 }
6522
6523
6524 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6525 PyObject *resultobj;
6526 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6527 int *arg2 = (int *) 0 ;
6528 int *arg3 = (int *) 0 ;
6529 int temp2 ;
6530 int res2 = 0 ;
6531 int temp3 ;
6532 int res3 = 0 ;
6533 PyObject * obj0 = 0 ;
6534 char *kwnames[] = {
6535 (char *) "self", NULL
6536 };
6537
6538 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6539 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6542 if (SWIG_arg_fail(1)) SWIG_fail;
6543 {
6544 PyThreadState* __tstate = wxPyBeginAllowThreads();
6545 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6546
6547 wxPyEndAllowThreads(__tstate);
6548 if (PyErr_Occurred()) SWIG_fail;
6549 }
6550 Py_INCREF(Py_None); resultobj = Py_None;
6551 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6552 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6553 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6554 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6555 return resultobj;
6556 fail:
6557 return NULL;
6558 }
6559
6560
6561 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6562 PyObject *resultobj;
6563 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6564 int *arg2 = (int *) 0 ;
6565 int *arg3 = (int *) 0 ;
6566 int temp2 ;
6567 int res2 = 0 ;
6568 int temp3 ;
6569 int res3 = 0 ;
6570 PyObject * obj0 = 0 ;
6571 char *kwnames[] = {
6572 (char *) "self", NULL
6573 };
6574
6575 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6576 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6579 if (SWIG_arg_fail(1)) SWIG_fail;
6580 {
6581 PyThreadState* __tstate = wxPyBeginAllowThreads();
6582 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6583
6584 wxPyEndAllowThreads(__tstate);
6585 if (PyErr_Occurred()) SWIG_fail;
6586 }
6587 Py_INCREF(Py_None); resultobj = Py_None;
6588 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6589 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6590 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6591 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6592 return resultobj;
6593 fail:
6594 return NULL;
6595 }
6596
6597
6598 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6599 PyObject *resultobj;
6600 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6601 double result;
6602 PyObject * obj0 = 0 ;
6603 char *kwnames[] = {
6604 (char *) "self", NULL
6605 };
6606
6607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6609 if (SWIG_arg_fail(1)) SWIG_fail;
6610 {
6611 PyThreadState* __tstate = wxPyBeginAllowThreads();
6612 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6613
6614 wxPyEndAllowThreads(__tstate);
6615 if (PyErr_Occurred()) SWIG_fail;
6616 }
6617 {
6618 resultobj = SWIG_From_double((double)(result));
6619 }
6620 return resultobj;
6621 fail:
6622 return NULL;
6623 }
6624
6625
6626 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6627 PyObject *resultobj;
6628 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6629 double result;
6630 PyObject * obj0 = 0 ;
6631 char *kwnames[] = {
6632 (char *) "self", NULL
6633 };
6634
6635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6637 if (SWIG_arg_fail(1)) SWIG_fail;
6638 {
6639 PyThreadState* __tstate = wxPyBeginAllowThreads();
6640 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6641
6642 wxPyEndAllowThreads(__tstate);
6643 if (PyErr_Occurred()) SWIG_fail;
6644 }
6645 {
6646 resultobj = SWIG_From_double((double)(result));
6647 }
6648 return resultobj;
6649 fail:
6650 return NULL;
6651 }
6652
6653
6654 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6655 PyObject *resultobj;
6656 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6657 double arg2 ;
6658 PyObject * obj0 = 0 ;
6659 PyObject * obj1 = 0 ;
6660 char *kwnames[] = {
6661 (char *) "self",(char *) "length", NULL
6662 };
6663
6664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6666 if (SWIG_arg_fail(1)) SWIG_fail;
6667 {
6668 arg2 = (double)(SWIG_As_double(obj1));
6669 if (SWIG_arg_fail(2)) SWIG_fail;
6670 }
6671 {
6672 PyThreadState* __tstate = wxPyBeginAllowThreads();
6673 (arg1)->SetVectorLength(arg2);
6674
6675 wxPyEndAllowThreads(__tstate);
6676 if (PyErr_Occurred()) SWIG_fail;
6677 }
6678 Py_INCREF(Py_None); resultobj = Py_None;
6679 return resultobj;
6680 fail:
6681 return NULL;
6682 }
6683
6684
6685 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6686 PyObject *resultobj;
6687 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6688 double arg2 ;
6689 PyObject * obj0 = 0 ;
6690 PyObject * obj1 = 0 ;
6691 char *kwnames[] = {
6692 (char *) "self",(char *) "degrees", NULL
6693 };
6694
6695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6697 if (SWIG_arg_fail(1)) SWIG_fail;
6698 {
6699 arg2 = (double)(SWIG_As_double(obj1));
6700 if (SWIG_arg_fail(2)) SWIG_fail;
6701 }
6702 {
6703 PyThreadState* __tstate = wxPyBeginAllowThreads();
6704 (arg1)->SetVectorAngle(arg2);
6705
6706 wxPyEndAllowThreads(__tstate);
6707 if (PyErr_Occurred()) SWIG_fail;
6708 }
6709 Py_INCREF(Py_None); resultobj = Py_None;
6710 return resultobj;
6711 fail:
6712 return NULL;
6713 }
6714
6715
6716 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6717 PyObject *resultobj;
6718 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6719 wxPoint2D *arg2 = 0 ;
6720 double result;
6721 wxPoint2D temp2 ;
6722 PyObject * obj0 = 0 ;
6723 PyObject * obj1 = 0 ;
6724 char *kwnames[] = {
6725 (char *) "self",(char *) "pt", NULL
6726 };
6727
6728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6730 if (SWIG_arg_fail(1)) SWIG_fail;
6731 {
6732 arg2 = &temp2;
6733 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6734 }
6735 {
6736 PyThreadState* __tstate = wxPyBeginAllowThreads();
6737 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6738
6739 wxPyEndAllowThreads(__tstate);
6740 if (PyErr_Occurred()) SWIG_fail;
6741 }
6742 {
6743 resultobj = SWIG_From_double((double)(result));
6744 }
6745 return resultobj;
6746 fail:
6747 return NULL;
6748 }
6749
6750
6751 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6752 PyObject *resultobj;
6753 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6754 wxPoint2D *arg2 = 0 ;
6755 double result;
6756 wxPoint2D temp2 ;
6757 PyObject * obj0 = 0 ;
6758 PyObject * obj1 = 0 ;
6759 char *kwnames[] = {
6760 (char *) "self",(char *) "pt", NULL
6761 };
6762
6763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6765 if (SWIG_arg_fail(1)) SWIG_fail;
6766 {
6767 arg2 = &temp2;
6768 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6769 }
6770 {
6771 PyThreadState* __tstate = wxPyBeginAllowThreads();
6772 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6773
6774 wxPyEndAllowThreads(__tstate);
6775 if (PyErr_Occurred()) SWIG_fail;
6776 }
6777 {
6778 resultobj = SWIG_From_double((double)(result));
6779 }
6780 return resultobj;
6781 fail:
6782 return NULL;
6783 }
6784
6785
6786 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6787 PyObject *resultobj;
6788 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6789 wxPoint2D *arg2 = 0 ;
6790 double result;
6791 wxPoint2D temp2 ;
6792 PyObject * obj0 = 0 ;
6793 PyObject * obj1 = 0 ;
6794 char *kwnames[] = {
6795 (char *) "self",(char *) "vec", NULL
6796 };
6797
6798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6800 if (SWIG_arg_fail(1)) SWIG_fail;
6801 {
6802 arg2 = &temp2;
6803 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6804 }
6805 {
6806 PyThreadState* __tstate = wxPyBeginAllowThreads();
6807 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6808
6809 wxPyEndAllowThreads(__tstate);
6810 if (PyErr_Occurred()) SWIG_fail;
6811 }
6812 {
6813 resultobj = SWIG_From_double((double)(result));
6814 }
6815 return resultobj;
6816 fail:
6817 return NULL;
6818 }
6819
6820
6821 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6822 PyObject *resultobj;
6823 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6824 wxPoint2D *arg2 = 0 ;
6825 double result;
6826 wxPoint2D temp2 ;
6827 PyObject * obj0 = 0 ;
6828 PyObject * obj1 = 0 ;
6829 char *kwnames[] = {
6830 (char *) "self",(char *) "vec", NULL
6831 };
6832
6833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6835 if (SWIG_arg_fail(1)) SWIG_fail;
6836 {
6837 arg2 = &temp2;
6838 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6839 }
6840 {
6841 PyThreadState* __tstate = wxPyBeginAllowThreads();
6842 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6843
6844 wxPyEndAllowThreads(__tstate);
6845 if (PyErr_Occurred()) SWIG_fail;
6846 }
6847 {
6848 resultobj = SWIG_From_double((double)(result));
6849 }
6850 return resultobj;
6851 fail:
6852 return NULL;
6853 }
6854
6855
6856 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6857 PyObject *resultobj;
6858 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6859 wxPoint2D result;
6860 PyObject * obj0 = 0 ;
6861 char *kwnames[] = {
6862 (char *) "self", NULL
6863 };
6864
6865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6867 if (SWIG_arg_fail(1)) SWIG_fail;
6868 {
6869 PyThreadState* __tstate = wxPyBeginAllowThreads();
6870 result = (arg1)->operator -();
6871
6872 wxPyEndAllowThreads(__tstate);
6873 if (PyErr_Occurred()) SWIG_fail;
6874 }
6875 {
6876 wxPoint2D * resultptr;
6877 resultptr = new wxPoint2D((wxPoint2D &)(result));
6878 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6879 }
6880 return resultobj;
6881 fail:
6882 return NULL;
6883 }
6884
6885
6886 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6887 PyObject *resultobj;
6888 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6889 wxPoint2D *arg2 = 0 ;
6890 wxPoint2D *result;
6891 wxPoint2D temp2 ;
6892 PyObject * obj0 = 0 ;
6893 PyObject * obj1 = 0 ;
6894 char *kwnames[] = {
6895 (char *) "self",(char *) "pt", NULL
6896 };
6897
6898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6900 if (SWIG_arg_fail(1)) SWIG_fail;
6901 {
6902 arg2 = &temp2;
6903 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6904 }
6905 {
6906 PyThreadState* __tstate = wxPyBeginAllowThreads();
6907 {
6908 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6909 result = (wxPoint2D *) &_result_ref;
6910 }
6911
6912 wxPyEndAllowThreads(__tstate);
6913 if (PyErr_Occurred()) SWIG_fail;
6914 }
6915 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6916 return resultobj;
6917 fail:
6918 return NULL;
6919 }
6920
6921
6922 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6923 PyObject *resultobj;
6924 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6925 wxPoint2D *arg2 = 0 ;
6926 wxPoint2D *result;
6927 wxPoint2D temp2 ;
6928 PyObject * obj0 = 0 ;
6929 PyObject * obj1 = 0 ;
6930 char *kwnames[] = {
6931 (char *) "self",(char *) "pt", NULL
6932 };
6933
6934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6936 if (SWIG_arg_fail(1)) SWIG_fail;
6937 {
6938 arg2 = &temp2;
6939 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6940 }
6941 {
6942 PyThreadState* __tstate = wxPyBeginAllowThreads();
6943 {
6944 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6945 result = (wxPoint2D *) &_result_ref;
6946 }
6947
6948 wxPyEndAllowThreads(__tstate);
6949 if (PyErr_Occurred()) SWIG_fail;
6950 }
6951 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6952 return resultobj;
6953 fail:
6954 return NULL;
6955 }
6956
6957
6958 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
6959 PyObject *resultobj;
6960 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6961 wxPoint2D *arg2 = 0 ;
6962 wxPoint2D *result;
6963 wxPoint2D temp2 ;
6964 PyObject * obj0 = 0 ;
6965 PyObject * obj1 = 0 ;
6966 char *kwnames[] = {
6967 (char *) "self",(char *) "pt", NULL
6968 };
6969
6970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
6971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6972 if (SWIG_arg_fail(1)) SWIG_fail;
6973 {
6974 arg2 = &temp2;
6975 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6976 }
6977 {
6978 PyThreadState* __tstate = wxPyBeginAllowThreads();
6979 {
6980 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
6981 result = (wxPoint2D *) &_result_ref;
6982 }
6983
6984 wxPyEndAllowThreads(__tstate);
6985 if (PyErr_Occurred()) SWIG_fail;
6986 }
6987 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6988 return resultobj;
6989 fail:
6990 return NULL;
6991 }
6992
6993
6994 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
6995 PyObject *resultobj;
6996 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6997 wxPoint2D *arg2 = 0 ;
6998 wxPoint2D *result;
6999 wxPoint2D temp2 ;
7000 PyObject * obj0 = 0 ;
7001 PyObject * obj1 = 0 ;
7002 char *kwnames[] = {
7003 (char *) "self",(char *) "pt", NULL
7004 };
7005
7006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7008 if (SWIG_arg_fail(1)) SWIG_fail;
7009 {
7010 arg2 = &temp2;
7011 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7012 }
7013 {
7014 PyThreadState* __tstate = wxPyBeginAllowThreads();
7015 {
7016 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7017 result = (wxPoint2D *) &_result_ref;
7018 }
7019
7020 wxPyEndAllowThreads(__tstate);
7021 if (PyErr_Occurred()) SWIG_fail;
7022 }
7023 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7024 return resultobj;
7025 fail:
7026 return NULL;
7027 }
7028
7029
7030 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7031 PyObject *resultobj;
7032 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7033 wxPoint2D *arg2 = 0 ;
7034 bool result;
7035 wxPoint2D temp2 ;
7036 PyObject * obj0 = 0 ;
7037 PyObject * obj1 = 0 ;
7038 char *kwnames[] = {
7039 (char *) "self",(char *) "pt", NULL
7040 };
7041
7042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7044 if (SWIG_arg_fail(1)) SWIG_fail;
7045 {
7046 arg2 = &temp2;
7047 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7048 }
7049 {
7050 PyThreadState* __tstate = wxPyBeginAllowThreads();
7051 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7052
7053 wxPyEndAllowThreads(__tstate);
7054 if (PyErr_Occurred()) SWIG_fail;
7055 }
7056 {
7057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7058 }
7059 return resultobj;
7060 fail:
7061 return NULL;
7062 }
7063
7064
7065 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7066 PyObject *resultobj;
7067 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7068 wxPoint2D *arg2 = 0 ;
7069 bool result;
7070 wxPoint2D temp2 ;
7071 PyObject * obj0 = 0 ;
7072 PyObject * obj1 = 0 ;
7073 char *kwnames[] = {
7074 (char *) "self",(char *) "pt", NULL
7075 };
7076
7077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7079 if (SWIG_arg_fail(1)) SWIG_fail;
7080 {
7081 arg2 = &temp2;
7082 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7083 }
7084 {
7085 PyThreadState* __tstate = wxPyBeginAllowThreads();
7086 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7087
7088 wxPyEndAllowThreads(__tstate);
7089 if (PyErr_Occurred()) SWIG_fail;
7090 }
7091 {
7092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7093 }
7094 return resultobj;
7095 fail:
7096 return NULL;
7097 }
7098
7099
7100 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7101 PyObject *resultobj;
7102 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7103 double arg2 ;
7104 PyObject * obj0 = 0 ;
7105 PyObject * obj1 = 0 ;
7106 char *kwnames[] = {
7107 (char *) "self",(char *) "m_x", NULL
7108 };
7109
7110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7112 if (SWIG_arg_fail(1)) SWIG_fail;
7113 {
7114 arg2 = (double)(SWIG_As_double(obj1));
7115 if (SWIG_arg_fail(2)) SWIG_fail;
7116 }
7117 if (arg1) (arg1)->m_x = arg2;
7118
7119 Py_INCREF(Py_None); resultobj = Py_None;
7120 return resultobj;
7121 fail:
7122 return NULL;
7123 }
7124
7125
7126 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7127 PyObject *resultobj;
7128 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7129 double result;
7130 PyObject * obj0 = 0 ;
7131 char *kwnames[] = {
7132 (char *) "self", NULL
7133 };
7134
7135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7137 if (SWIG_arg_fail(1)) SWIG_fail;
7138 result = (double) ((arg1)->m_x);
7139
7140 {
7141 resultobj = SWIG_From_double((double)(result));
7142 }
7143 return resultobj;
7144 fail:
7145 return NULL;
7146 }
7147
7148
7149 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7150 PyObject *resultobj;
7151 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7152 double arg2 ;
7153 PyObject * obj0 = 0 ;
7154 PyObject * obj1 = 0 ;
7155 char *kwnames[] = {
7156 (char *) "self",(char *) "m_y", NULL
7157 };
7158
7159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7161 if (SWIG_arg_fail(1)) SWIG_fail;
7162 {
7163 arg2 = (double)(SWIG_As_double(obj1));
7164 if (SWIG_arg_fail(2)) SWIG_fail;
7165 }
7166 if (arg1) (arg1)->m_y = arg2;
7167
7168 Py_INCREF(Py_None); resultobj = Py_None;
7169 return resultobj;
7170 fail:
7171 return NULL;
7172 }
7173
7174
7175 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7176 PyObject *resultobj;
7177 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7178 double result;
7179 PyObject * obj0 = 0 ;
7180 char *kwnames[] = {
7181 (char *) "self", NULL
7182 };
7183
7184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7186 if (SWIG_arg_fail(1)) SWIG_fail;
7187 result = (double) ((arg1)->m_y);
7188
7189 {
7190 resultobj = SWIG_From_double((double)(result));
7191 }
7192 return resultobj;
7193 fail:
7194 return NULL;
7195 }
7196
7197
7198 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7199 PyObject *resultobj;
7200 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7201 double arg2 = (double) 0 ;
7202 double arg3 = (double) 0 ;
7203 PyObject * obj0 = 0 ;
7204 PyObject * obj1 = 0 ;
7205 PyObject * obj2 = 0 ;
7206 char *kwnames[] = {
7207 (char *) "self",(char *) "x",(char *) "y", NULL
7208 };
7209
7210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7212 if (SWIG_arg_fail(1)) SWIG_fail;
7213 if (obj1) {
7214 {
7215 arg2 = (double)(SWIG_As_double(obj1));
7216 if (SWIG_arg_fail(2)) SWIG_fail;
7217 }
7218 }
7219 if (obj2) {
7220 {
7221 arg3 = (double)(SWIG_As_double(obj2));
7222 if (SWIG_arg_fail(3)) SWIG_fail;
7223 }
7224 }
7225 {
7226 PyThreadState* __tstate = wxPyBeginAllowThreads();
7227 wxPoint2D_Set(arg1,arg2,arg3);
7228
7229 wxPyEndAllowThreads(__tstate);
7230 if (PyErr_Occurred()) SWIG_fail;
7231 }
7232 Py_INCREF(Py_None); resultobj = Py_None;
7233 return resultobj;
7234 fail:
7235 return NULL;
7236 }
7237
7238
7239 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7240 PyObject *resultobj;
7241 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7242 PyObject *result;
7243 PyObject * obj0 = 0 ;
7244 char *kwnames[] = {
7245 (char *) "self", NULL
7246 };
7247
7248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7250 if (SWIG_arg_fail(1)) SWIG_fail;
7251 {
7252 PyThreadState* __tstate = wxPyBeginAllowThreads();
7253 result = (PyObject *)wxPoint2D_Get(arg1);
7254
7255 wxPyEndAllowThreads(__tstate);
7256 if (PyErr_Occurred()) SWIG_fail;
7257 }
7258 resultobj = result;
7259 return resultobj;
7260 fail:
7261 return NULL;
7262 }
7263
7264
7265 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7266 PyObject *obj;
7267 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7268 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7269 Py_INCREF(obj);
7270 return Py_BuildValue((char *)"");
7271 }
7272 static int _wrap_DefaultPosition_set(PyObject *) {
7273 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7274 return 1;
7275 }
7276
7277
7278 static PyObject *_wrap_DefaultPosition_get(void) {
7279 PyObject *pyobj;
7280
7281 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7282 return pyobj;
7283 }
7284
7285
7286 static int _wrap_DefaultSize_set(PyObject *) {
7287 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7288 return 1;
7289 }
7290
7291
7292 static PyObject *_wrap_DefaultSize_get(void) {
7293 PyObject *pyobj;
7294
7295 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7296 return pyobj;
7297 }
7298
7299
7300 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7301 PyObject *resultobj;
7302 PyObject *arg1 = (PyObject *) 0 ;
7303 wxPyInputStream *result;
7304 PyObject * obj0 = 0 ;
7305 char *kwnames[] = {
7306 (char *) "p", NULL
7307 };
7308
7309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7310 arg1 = obj0;
7311 {
7312 PyThreadState* __tstate = wxPyBeginAllowThreads();
7313 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7314
7315 wxPyEndAllowThreads(__tstate);
7316 if (PyErr_Occurred()) SWIG_fail;
7317 }
7318 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7319 return resultobj;
7320 fail:
7321 return NULL;
7322 }
7323
7324
7325 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7326 PyObject *resultobj;
7327 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7328 PyObject * obj0 = 0 ;
7329 char *kwnames[] = {
7330 (char *) "self", NULL
7331 };
7332
7333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7335 if (SWIG_arg_fail(1)) SWIG_fail;
7336 {
7337 PyThreadState* __tstate = wxPyBeginAllowThreads();
7338 delete arg1;
7339
7340 wxPyEndAllowThreads(__tstate);
7341 if (PyErr_Occurred()) SWIG_fail;
7342 }
7343 Py_INCREF(Py_None); resultobj = Py_None;
7344 return resultobj;
7345 fail:
7346 return NULL;
7347 }
7348
7349
7350 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7351 PyObject *resultobj;
7352 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7353 PyObject * obj0 = 0 ;
7354 char *kwnames[] = {
7355 (char *) "self", NULL
7356 };
7357
7358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7360 if (SWIG_arg_fail(1)) SWIG_fail;
7361 {
7362 PyThreadState* __tstate = wxPyBeginAllowThreads();
7363 (arg1)->close();
7364
7365 wxPyEndAllowThreads(__tstate);
7366 if (PyErr_Occurred()) SWIG_fail;
7367 }
7368 Py_INCREF(Py_None); resultobj = Py_None;
7369 return resultobj;
7370 fail:
7371 return NULL;
7372 }
7373
7374
7375 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7376 PyObject *resultobj;
7377 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7378 PyObject * obj0 = 0 ;
7379 char *kwnames[] = {
7380 (char *) "self", NULL
7381 };
7382
7383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7385 if (SWIG_arg_fail(1)) SWIG_fail;
7386 {
7387 PyThreadState* __tstate = wxPyBeginAllowThreads();
7388 (arg1)->flush();
7389
7390 wxPyEndAllowThreads(__tstate);
7391 if (PyErr_Occurred()) SWIG_fail;
7392 }
7393 Py_INCREF(Py_None); resultobj = Py_None;
7394 return resultobj;
7395 fail:
7396 return NULL;
7397 }
7398
7399
7400 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7401 PyObject *resultobj;
7402 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7403 bool result;
7404 PyObject * obj0 = 0 ;
7405 char *kwnames[] = {
7406 (char *) "self", NULL
7407 };
7408
7409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7411 if (SWIG_arg_fail(1)) SWIG_fail;
7412 {
7413 PyThreadState* __tstate = wxPyBeginAllowThreads();
7414 result = (bool)(arg1)->eof();
7415
7416 wxPyEndAllowThreads(__tstate);
7417 if (PyErr_Occurred()) SWIG_fail;
7418 }
7419 {
7420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7421 }
7422 return resultobj;
7423 fail:
7424 return NULL;
7425 }
7426
7427
7428 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7429 PyObject *resultobj;
7430 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7431 int arg2 = (int) -1 ;
7432 PyObject *result;
7433 PyObject * obj0 = 0 ;
7434 PyObject * obj1 = 0 ;
7435 char *kwnames[] = {
7436 (char *) "self",(char *) "size", NULL
7437 };
7438
7439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7441 if (SWIG_arg_fail(1)) SWIG_fail;
7442 if (obj1) {
7443 {
7444 arg2 = (int)(SWIG_As_int(obj1));
7445 if (SWIG_arg_fail(2)) SWIG_fail;
7446 }
7447 }
7448 {
7449 PyThreadState* __tstate = wxPyBeginAllowThreads();
7450 result = (PyObject *)(arg1)->read(arg2);
7451
7452 wxPyEndAllowThreads(__tstate);
7453 if (PyErr_Occurred()) SWIG_fail;
7454 }
7455 resultobj = result;
7456 return resultobj;
7457 fail:
7458 return NULL;
7459 }
7460
7461
7462 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7463 PyObject *resultobj;
7464 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7465 int arg2 = (int) -1 ;
7466 PyObject *result;
7467 PyObject * obj0 = 0 ;
7468 PyObject * obj1 = 0 ;
7469 char *kwnames[] = {
7470 (char *) "self",(char *) "size", NULL
7471 };
7472
7473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7475 if (SWIG_arg_fail(1)) SWIG_fail;
7476 if (obj1) {
7477 {
7478 arg2 = (int)(SWIG_As_int(obj1));
7479 if (SWIG_arg_fail(2)) SWIG_fail;
7480 }
7481 }
7482 {
7483 PyThreadState* __tstate = wxPyBeginAllowThreads();
7484 result = (PyObject *)(arg1)->readline(arg2);
7485
7486 wxPyEndAllowThreads(__tstate);
7487 if (PyErr_Occurred()) SWIG_fail;
7488 }
7489 resultobj = result;
7490 return resultobj;
7491 fail:
7492 return NULL;
7493 }
7494
7495
7496 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7497 PyObject *resultobj;
7498 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7499 int arg2 = (int) -1 ;
7500 PyObject *result;
7501 PyObject * obj0 = 0 ;
7502 PyObject * obj1 = 0 ;
7503 char *kwnames[] = {
7504 (char *) "self",(char *) "sizehint", NULL
7505 };
7506
7507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7509 if (SWIG_arg_fail(1)) SWIG_fail;
7510 if (obj1) {
7511 {
7512 arg2 = (int)(SWIG_As_int(obj1));
7513 if (SWIG_arg_fail(2)) SWIG_fail;
7514 }
7515 }
7516 {
7517 PyThreadState* __tstate = wxPyBeginAllowThreads();
7518 result = (PyObject *)(arg1)->readlines(arg2);
7519
7520 wxPyEndAllowThreads(__tstate);
7521 if (PyErr_Occurred()) SWIG_fail;
7522 }
7523 resultobj = result;
7524 return resultobj;
7525 fail:
7526 return NULL;
7527 }
7528
7529
7530 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7531 PyObject *resultobj;
7532 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7533 int arg2 ;
7534 int arg3 = (int) 0 ;
7535 PyObject * obj0 = 0 ;
7536 PyObject * obj1 = 0 ;
7537 PyObject * obj2 = 0 ;
7538 char *kwnames[] = {
7539 (char *) "self",(char *) "offset",(char *) "whence", NULL
7540 };
7541
7542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7544 if (SWIG_arg_fail(1)) SWIG_fail;
7545 {
7546 arg2 = (int)(SWIG_As_int(obj1));
7547 if (SWIG_arg_fail(2)) SWIG_fail;
7548 }
7549 if (obj2) {
7550 {
7551 arg3 = (int)(SWIG_As_int(obj2));
7552 if (SWIG_arg_fail(3)) SWIG_fail;
7553 }
7554 }
7555 {
7556 PyThreadState* __tstate = wxPyBeginAllowThreads();
7557 (arg1)->seek(arg2,arg3);
7558
7559 wxPyEndAllowThreads(__tstate);
7560 if (PyErr_Occurred()) SWIG_fail;
7561 }
7562 Py_INCREF(Py_None); resultobj = Py_None;
7563 return resultobj;
7564 fail:
7565 return NULL;
7566 }
7567
7568
7569 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7570 PyObject *resultobj;
7571 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7572 int result;
7573 PyObject * obj0 = 0 ;
7574 char *kwnames[] = {
7575 (char *) "self", NULL
7576 };
7577
7578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7580 if (SWIG_arg_fail(1)) SWIG_fail;
7581 {
7582 PyThreadState* __tstate = wxPyBeginAllowThreads();
7583 result = (int)(arg1)->tell();
7584
7585 wxPyEndAllowThreads(__tstate);
7586 if (PyErr_Occurred()) SWIG_fail;
7587 }
7588 {
7589 resultobj = SWIG_From_int((int)(result));
7590 }
7591 return resultobj;
7592 fail:
7593 return NULL;
7594 }
7595
7596
7597 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7598 PyObject *resultobj;
7599 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7600 char result;
7601 PyObject * obj0 = 0 ;
7602 char *kwnames[] = {
7603 (char *) "self", NULL
7604 };
7605
7606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7608 if (SWIG_arg_fail(1)) SWIG_fail;
7609 {
7610 PyThreadState* __tstate = wxPyBeginAllowThreads();
7611 result = (char)(arg1)->Peek();
7612
7613 wxPyEndAllowThreads(__tstate);
7614 if (PyErr_Occurred()) SWIG_fail;
7615 }
7616 {
7617 resultobj = SWIG_From_char((char)(result));
7618 }
7619 return resultobj;
7620 fail:
7621 return NULL;
7622 }
7623
7624
7625 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7626 PyObject *resultobj;
7627 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7628 char result;
7629 PyObject * obj0 = 0 ;
7630 char *kwnames[] = {
7631 (char *) "self", NULL
7632 };
7633
7634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7636 if (SWIG_arg_fail(1)) SWIG_fail;
7637 {
7638 PyThreadState* __tstate = wxPyBeginAllowThreads();
7639 result = (char)(arg1)->GetC();
7640
7641 wxPyEndAllowThreads(__tstate);
7642 if (PyErr_Occurred()) SWIG_fail;
7643 }
7644 {
7645 resultobj = SWIG_From_char((char)(result));
7646 }
7647 return resultobj;
7648 fail:
7649 return NULL;
7650 }
7651
7652
7653 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7654 PyObject *resultobj;
7655 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7656 size_t result;
7657 PyObject * obj0 = 0 ;
7658 char *kwnames[] = {
7659 (char *) "self", NULL
7660 };
7661
7662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7664 if (SWIG_arg_fail(1)) SWIG_fail;
7665 {
7666 PyThreadState* __tstate = wxPyBeginAllowThreads();
7667 result = (size_t)(arg1)->LastRead();
7668
7669 wxPyEndAllowThreads(__tstate);
7670 if (PyErr_Occurred()) SWIG_fail;
7671 }
7672 {
7673 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7674 }
7675 return resultobj;
7676 fail:
7677 return NULL;
7678 }
7679
7680
7681 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7682 PyObject *resultobj;
7683 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7684 bool result;
7685 PyObject * obj0 = 0 ;
7686 char *kwnames[] = {
7687 (char *) "self", NULL
7688 };
7689
7690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7692 if (SWIG_arg_fail(1)) SWIG_fail;
7693 {
7694 PyThreadState* __tstate = wxPyBeginAllowThreads();
7695 result = (bool)(arg1)->CanRead();
7696
7697 wxPyEndAllowThreads(__tstate);
7698 if (PyErr_Occurred()) SWIG_fail;
7699 }
7700 {
7701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7702 }
7703 return resultobj;
7704 fail:
7705 return NULL;
7706 }
7707
7708
7709 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7710 PyObject *resultobj;
7711 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7712 bool result;
7713 PyObject * obj0 = 0 ;
7714 char *kwnames[] = {
7715 (char *) "self", NULL
7716 };
7717
7718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7720 if (SWIG_arg_fail(1)) SWIG_fail;
7721 {
7722 PyThreadState* __tstate = wxPyBeginAllowThreads();
7723 result = (bool)(arg1)->Eof();
7724
7725 wxPyEndAllowThreads(__tstate);
7726 if (PyErr_Occurred()) SWIG_fail;
7727 }
7728 {
7729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7730 }
7731 return resultobj;
7732 fail:
7733 return NULL;
7734 }
7735
7736
7737 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7738 PyObject *resultobj;
7739 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7740 char arg2 ;
7741 bool result;
7742 PyObject * obj0 = 0 ;
7743 PyObject * obj1 = 0 ;
7744 char *kwnames[] = {
7745 (char *) "self",(char *) "c", NULL
7746 };
7747
7748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7750 if (SWIG_arg_fail(1)) SWIG_fail;
7751 {
7752 arg2 = (char)(SWIG_As_char(obj1));
7753 if (SWIG_arg_fail(2)) SWIG_fail;
7754 }
7755 {
7756 PyThreadState* __tstate = wxPyBeginAllowThreads();
7757 result = (bool)(arg1)->Ungetch(arg2);
7758
7759 wxPyEndAllowThreads(__tstate);
7760 if (PyErr_Occurred()) SWIG_fail;
7761 }
7762 {
7763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7764 }
7765 return resultobj;
7766 fail:
7767 return NULL;
7768 }
7769
7770
7771 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7772 PyObject *resultobj;
7773 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7774 long arg2 ;
7775 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7776 long result;
7777 PyObject * obj0 = 0 ;
7778 PyObject * obj1 = 0 ;
7779 PyObject * obj2 = 0 ;
7780 char *kwnames[] = {
7781 (char *) "self",(char *) "pos",(char *) "mode", NULL
7782 };
7783
7784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7786 if (SWIG_arg_fail(1)) SWIG_fail;
7787 {
7788 arg2 = (long)(SWIG_As_long(obj1));
7789 if (SWIG_arg_fail(2)) SWIG_fail;
7790 }
7791 if (obj2) {
7792 {
7793 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7794 if (SWIG_arg_fail(3)) SWIG_fail;
7795 }
7796 }
7797 {
7798 PyThreadState* __tstate = wxPyBeginAllowThreads();
7799 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7800
7801 wxPyEndAllowThreads(__tstate);
7802 if (PyErr_Occurred()) SWIG_fail;
7803 }
7804 {
7805 resultobj = SWIG_From_long((long)(result));
7806 }
7807 return resultobj;
7808 fail:
7809 return NULL;
7810 }
7811
7812
7813 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7814 PyObject *resultobj;
7815 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7816 long result;
7817 PyObject * obj0 = 0 ;
7818 char *kwnames[] = {
7819 (char *) "self", NULL
7820 };
7821
7822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7824 if (SWIG_arg_fail(1)) SWIG_fail;
7825 {
7826 PyThreadState* __tstate = wxPyBeginAllowThreads();
7827 result = (long)(arg1)->TellI();
7828
7829 wxPyEndAllowThreads(__tstate);
7830 if (PyErr_Occurred()) SWIG_fail;
7831 }
7832 {
7833 resultobj = SWIG_From_long((long)(result));
7834 }
7835 return resultobj;
7836 fail:
7837 return NULL;
7838 }
7839
7840
7841 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7842 PyObject *obj;
7843 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7844 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7845 Py_INCREF(obj);
7846 return Py_BuildValue((char *)"");
7847 }
7848 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7849 PyObject *resultobj;
7850 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7851 PyObject *arg2 = (PyObject *) 0 ;
7852 PyObject * obj0 = 0 ;
7853 PyObject * obj1 = 0 ;
7854 char *kwnames[] = {
7855 (char *) "self",(char *) "obj", NULL
7856 };
7857
7858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7860 if (SWIG_arg_fail(1)) SWIG_fail;
7861 arg2 = obj1;
7862 {
7863 PyThreadState* __tstate = wxPyBeginAllowThreads();
7864 wxOutputStream_write(arg1,arg2);
7865
7866 wxPyEndAllowThreads(__tstate);
7867 if (PyErr_Occurred()) SWIG_fail;
7868 }
7869 Py_INCREF(Py_None); resultobj = Py_None;
7870 return resultobj;
7871 fail:
7872 return NULL;
7873 }
7874
7875
7876 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7877 PyObject *obj;
7878 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7879 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7880 Py_INCREF(obj);
7881 return Py_BuildValue((char *)"");
7882 }
7883 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7884 PyObject *resultobj;
7885 wxInputStream *arg1 = (wxInputStream *) 0 ;
7886 wxString *arg2 = 0 ;
7887 wxString *arg3 = 0 ;
7888 wxString *arg4 = 0 ;
7889 wxDateTime arg5 ;
7890 wxFSFile *result;
7891 wxPyInputStream *temp1 ;
7892 bool created1 ;
7893 bool temp2 = false ;
7894 bool temp3 = false ;
7895 bool temp4 = false ;
7896 PyObject * obj0 = 0 ;
7897 PyObject * obj1 = 0 ;
7898 PyObject * obj2 = 0 ;
7899 PyObject * obj3 = 0 ;
7900 PyObject * obj4 = 0 ;
7901 char *kwnames[] = {
7902 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7903 };
7904
7905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7906 {
7907 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7908 arg1 = temp1->m_wxis;
7909 created1 = false;
7910 } else {
7911 PyErr_Clear(); // clear the failure of the wxPyConvert above
7912 arg1 = wxPyCBInputStream_create(obj0, false);
7913 if (arg1 == NULL) {
7914 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
7915 SWIG_fail;
7916 }
7917 created1 = true;
7918 }
7919 }
7920 {
7921 arg2 = wxString_in_helper(obj1);
7922 if (arg2 == NULL) SWIG_fail;
7923 temp2 = true;
7924 }
7925 {
7926 arg3 = wxString_in_helper(obj2);
7927 if (arg3 == NULL) SWIG_fail;
7928 temp3 = true;
7929 }
7930 {
7931 arg4 = wxString_in_helper(obj3);
7932 if (arg4 == NULL) SWIG_fail;
7933 temp4 = true;
7934 }
7935 {
7936 wxDateTime * argp;
7937 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7938 if (SWIG_arg_fail(5)) SWIG_fail;
7939 if (argp == NULL) {
7940 SWIG_null_ref("wxDateTime");
7941 }
7942 if (SWIG_arg_fail(5)) SWIG_fail;
7943 arg5 = *argp;
7944 }
7945 {
7946 PyThreadState* __tstate = wxPyBeginAllowThreads();
7947 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7948
7949 wxPyEndAllowThreads(__tstate);
7950 if (PyErr_Occurred()) SWIG_fail;
7951 }
7952 {
7953 resultobj = wxPyMake_wxObject(result, 1);
7954 }
7955 {
7956 if (created1)
7957 delete arg1;
7958 }
7959 {
7960 if (temp2)
7961 delete arg2;
7962 }
7963 {
7964 if (temp3)
7965 delete arg3;
7966 }
7967 {
7968 if (temp4)
7969 delete arg4;
7970 }
7971 return resultobj;
7972 fail:
7973 {
7974 if (created1)
7975 delete arg1;
7976 }
7977 {
7978 if (temp2)
7979 delete arg2;
7980 }
7981 {
7982 if (temp3)
7983 delete arg3;
7984 }
7985 {
7986 if (temp4)
7987 delete arg4;
7988 }
7989 return NULL;
7990 }
7991
7992
7993 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7994 PyObject *resultobj;
7995 wxFSFile *arg1 = (wxFSFile *) 0 ;
7996 PyObject * obj0 = 0 ;
7997 char *kwnames[] = {
7998 (char *) "self", NULL
7999 };
8000
8001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8003 if (SWIG_arg_fail(1)) SWIG_fail;
8004 {
8005 PyThreadState* __tstate = wxPyBeginAllowThreads();
8006 delete arg1;
8007
8008 wxPyEndAllowThreads(__tstate);
8009 if (PyErr_Occurred()) SWIG_fail;
8010 }
8011 Py_INCREF(Py_None); resultobj = Py_None;
8012 return resultobj;
8013 fail:
8014 return NULL;
8015 }
8016
8017
8018 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8019 PyObject *resultobj;
8020 wxFSFile *arg1 = (wxFSFile *) 0 ;
8021 wxInputStream *result;
8022 PyObject * obj0 = 0 ;
8023 char *kwnames[] = {
8024 (char *) "self", NULL
8025 };
8026
8027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8029 if (SWIG_arg_fail(1)) SWIG_fail;
8030 {
8031 PyThreadState* __tstate = wxPyBeginAllowThreads();
8032 result = (wxInputStream *)(arg1)->GetStream();
8033
8034 wxPyEndAllowThreads(__tstate);
8035 if (PyErr_Occurred()) SWIG_fail;
8036 }
8037 {
8038 wxPyInputStream * _ptr = NULL;
8039
8040 if (result) {
8041 _ptr = new wxPyInputStream(result);
8042 }
8043 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8044 }
8045 return resultobj;
8046 fail:
8047 return NULL;
8048 }
8049
8050
8051 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8052 PyObject *resultobj;
8053 wxFSFile *arg1 = (wxFSFile *) 0 ;
8054 wxString *result;
8055 PyObject * obj0 = 0 ;
8056 char *kwnames[] = {
8057 (char *) "self", NULL
8058 };
8059
8060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8062 if (SWIG_arg_fail(1)) SWIG_fail;
8063 {
8064 PyThreadState* __tstate = wxPyBeginAllowThreads();
8065 {
8066 wxString const &_result_ref = (arg1)->GetMimeType();
8067 result = (wxString *) &_result_ref;
8068 }
8069
8070 wxPyEndAllowThreads(__tstate);
8071 if (PyErr_Occurred()) SWIG_fail;
8072 }
8073 {
8074 #if wxUSE_UNICODE
8075 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8076 #else
8077 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8078 #endif
8079 }
8080 return resultobj;
8081 fail:
8082 return NULL;
8083 }
8084
8085
8086 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8087 PyObject *resultobj;
8088 wxFSFile *arg1 = (wxFSFile *) 0 ;
8089 wxString *result;
8090 PyObject * obj0 = 0 ;
8091 char *kwnames[] = {
8092 (char *) "self", NULL
8093 };
8094
8095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8097 if (SWIG_arg_fail(1)) SWIG_fail;
8098 {
8099 PyThreadState* __tstate = wxPyBeginAllowThreads();
8100 {
8101 wxString const &_result_ref = (arg1)->GetLocation();
8102 result = (wxString *) &_result_ref;
8103 }
8104
8105 wxPyEndAllowThreads(__tstate);
8106 if (PyErr_Occurred()) SWIG_fail;
8107 }
8108 {
8109 #if wxUSE_UNICODE
8110 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8111 #else
8112 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8113 #endif
8114 }
8115 return resultobj;
8116 fail:
8117 return NULL;
8118 }
8119
8120
8121 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8122 PyObject *resultobj;
8123 wxFSFile *arg1 = (wxFSFile *) 0 ;
8124 wxString *result;
8125 PyObject * obj0 = 0 ;
8126 char *kwnames[] = {
8127 (char *) "self", NULL
8128 };
8129
8130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8132 if (SWIG_arg_fail(1)) SWIG_fail;
8133 {
8134 PyThreadState* __tstate = wxPyBeginAllowThreads();
8135 {
8136 wxString const &_result_ref = (arg1)->GetAnchor();
8137 result = (wxString *) &_result_ref;
8138 }
8139
8140 wxPyEndAllowThreads(__tstate);
8141 if (PyErr_Occurred()) SWIG_fail;
8142 }
8143 {
8144 #if wxUSE_UNICODE
8145 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8146 #else
8147 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8148 #endif
8149 }
8150 return resultobj;
8151 fail:
8152 return NULL;
8153 }
8154
8155
8156 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8157 PyObject *resultobj;
8158 wxFSFile *arg1 = (wxFSFile *) 0 ;
8159 wxDateTime result;
8160 PyObject * obj0 = 0 ;
8161 char *kwnames[] = {
8162 (char *) "self", NULL
8163 };
8164
8165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8167 if (SWIG_arg_fail(1)) SWIG_fail;
8168 {
8169 PyThreadState* __tstate = wxPyBeginAllowThreads();
8170 result = (arg1)->GetModificationTime();
8171
8172 wxPyEndAllowThreads(__tstate);
8173 if (PyErr_Occurred()) SWIG_fail;
8174 }
8175 {
8176 wxDateTime * resultptr;
8177 resultptr = new wxDateTime((wxDateTime &)(result));
8178 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8179 }
8180 return resultobj;
8181 fail:
8182 return NULL;
8183 }
8184
8185
8186 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8187 PyObject *obj;
8188 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8189 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8190 Py_INCREF(obj);
8191 return Py_BuildValue((char *)"");
8192 }
8193 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8194 PyObject *obj;
8195 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8196 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8197 Py_INCREF(obj);
8198 return Py_BuildValue((char *)"");
8199 }
8200 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8201 PyObject *resultobj;
8202 wxPyFileSystemHandler *result;
8203 char *kwnames[] = {
8204 NULL
8205 };
8206
8207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8208 {
8209 PyThreadState* __tstate = wxPyBeginAllowThreads();
8210 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8211
8212 wxPyEndAllowThreads(__tstate);
8213 if (PyErr_Occurred()) SWIG_fail;
8214 }
8215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8216 return resultobj;
8217 fail:
8218 return NULL;
8219 }
8220
8221
8222 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8223 PyObject *resultobj;
8224 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8225 PyObject *arg2 = (PyObject *) 0 ;
8226 PyObject *arg3 = (PyObject *) 0 ;
8227 PyObject * obj0 = 0 ;
8228 PyObject * obj1 = 0 ;
8229 PyObject * obj2 = 0 ;
8230 char *kwnames[] = {
8231 (char *) "self",(char *) "self",(char *) "_class", NULL
8232 };
8233
8234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8236 if (SWIG_arg_fail(1)) SWIG_fail;
8237 arg2 = obj1;
8238 arg3 = obj2;
8239 {
8240 PyThreadState* __tstate = wxPyBeginAllowThreads();
8241 (arg1)->_setCallbackInfo(arg2,arg3);
8242
8243 wxPyEndAllowThreads(__tstate);
8244 if (PyErr_Occurred()) SWIG_fail;
8245 }
8246 Py_INCREF(Py_None); resultobj = Py_None;
8247 return resultobj;
8248 fail:
8249 return NULL;
8250 }
8251
8252
8253 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8254 PyObject *resultobj;
8255 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8256 wxString *arg2 = 0 ;
8257 bool result;
8258 bool temp2 = false ;
8259 PyObject * obj0 = 0 ;
8260 PyObject * obj1 = 0 ;
8261 char *kwnames[] = {
8262 (char *) "self",(char *) "location", NULL
8263 };
8264
8265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8267 if (SWIG_arg_fail(1)) SWIG_fail;
8268 {
8269 arg2 = wxString_in_helper(obj1);
8270 if (arg2 == NULL) SWIG_fail;
8271 temp2 = true;
8272 }
8273 {
8274 PyThreadState* __tstate = wxPyBeginAllowThreads();
8275 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8276
8277 wxPyEndAllowThreads(__tstate);
8278 if (PyErr_Occurred()) SWIG_fail;
8279 }
8280 {
8281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8282 }
8283 {
8284 if (temp2)
8285 delete arg2;
8286 }
8287 return resultobj;
8288 fail:
8289 {
8290 if (temp2)
8291 delete arg2;
8292 }
8293 return NULL;
8294 }
8295
8296
8297 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8298 PyObject *resultobj;
8299 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8300 wxFileSystem *arg2 = 0 ;
8301 wxString *arg3 = 0 ;
8302 wxFSFile *result;
8303 bool temp3 = false ;
8304 PyObject * obj0 = 0 ;
8305 PyObject * obj1 = 0 ;
8306 PyObject * obj2 = 0 ;
8307 char *kwnames[] = {
8308 (char *) "self",(char *) "fs",(char *) "location", NULL
8309 };
8310
8311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8313 if (SWIG_arg_fail(1)) SWIG_fail;
8314 {
8315 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8316 if (SWIG_arg_fail(2)) SWIG_fail;
8317 if (arg2 == NULL) {
8318 SWIG_null_ref("wxFileSystem");
8319 }
8320 if (SWIG_arg_fail(2)) SWIG_fail;
8321 }
8322 {
8323 arg3 = wxString_in_helper(obj2);
8324 if (arg3 == NULL) SWIG_fail;
8325 temp3 = true;
8326 }
8327 {
8328 PyThreadState* __tstate = wxPyBeginAllowThreads();
8329 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8330
8331 wxPyEndAllowThreads(__tstate);
8332 if (PyErr_Occurred()) SWIG_fail;
8333 }
8334 {
8335 resultobj = wxPyMake_wxObject(result, 1);
8336 }
8337 {
8338 if (temp3)
8339 delete arg3;
8340 }
8341 return resultobj;
8342 fail:
8343 {
8344 if (temp3)
8345 delete arg3;
8346 }
8347 return NULL;
8348 }
8349
8350
8351 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8352 PyObject *resultobj;
8353 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8354 wxString *arg2 = 0 ;
8355 int arg3 = (int) 0 ;
8356 wxString result;
8357 bool temp2 = false ;
8358 PyObject * obj0 = 0 ;
8359 PyObject * obj1 = 0 ;
8360 PyObject * obj2 = 0 ;
8361 char *kwnames[] = {
8362 (char *) "self",(char *) "spec",(char *) "flags", NULL
8363 };
8364
8365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8367 if (SWIG_arg_fail(1)) SWIG_fail;
8368 {
8369 arg2 = wxString_in_helper(obj1);
8370 if (arg2 == NULL) SWIG_fail;
8371 temp2 = true;
8372 }
8373 if (obj2) {
8374 {
8375 arg3 = (int)(SWIG_As_int(obj2));
8376 if (SWIG_arg_fail(3)) SWIG_fail;
8377 }
8378 }
8379 {
8380 PyThreadState* __tstate = wxPyBeginAllowThreads();
8381 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8382
8383 wxPyEndAllowThreads(__tstate);
8384 if (PyErr_Occurred()) SWIG_fail;
8385 }
8386 {
8387 #if wxUSE_UNICODE
8388 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8389 #else
8390 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8391 #endif
8392 }
8393 {
8394 if (temp2)
8395 delete arg2;
8396 }
8397 return resultobj;
8398 fail:
8399 {
8400 if (temp2)
8401 delete arg2;
8402 }
8403 return NULL;
8404 }
8405
8406
8407 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8408 PyObject *resultobj;
8409 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8410 wxString result;
8411 PyObject * obj0 = 0 ;
8412 char *kwnames[] = {
8413 (char *) "self", NULL
8414 };
8415
8416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8418 if (SWIG_arg_fail(1)) SWIG_fail;
8419 {
8420 PyThreadState* __tstate = wxPyBeginAllowThreads();
8421 result = (arg1)->FindNext();
8422
8423 wxPyEndAllowThreads(__tstate);
8424 if (PyErr_Occurred()) SWIG_fail;
8425 }
8426 {
8427 #if wxUSE_UNICODE
8428 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8429 #else
8430 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8431 #endif
8432 }
8433 return resultobj;
8434 fail:
8435 return NULL;
8436 }
8437
8438
8439 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8440 PyObject *resultobj;
8441 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8442 wxString *arg2 = 0 ;
8443 wxString result;
8444 bool temp2 = false ;
8445 PyObject * obj0 = 0 ;
8446 PyObject * obj1 = 0 ;
8447 char *kwnames[] = {
8448 (char *) "self",(char *) "location", NULL
8449 };
8450
8451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8453 if (SWIG_arg_fail(1)) SWIG_fail;
8454 {
8455 arg2 = wxString_in_helper(obj1);
8456 if (arg2 == NULL) SWIG_fail;
8457 temp2 = true;
8458 }
8459 {
8460 PyThreadState* __tstate = wxPyBeginAllowThreads();
8461 result = (arg1)->GetProtocol((wxString const &)*arg2);
8462
8463 wxPyEndAllowThreads(__tstate);
8464 if (PyErr_Occurred()) SWIG_fail;
8465 }
8466 {
8467 #if wxUSE_UNICODE
8468 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8469 #else
8470 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8471 #endif
8472 }
8473 {
8474 if (temp2)
8475 delete arg2;
8476 }
8477 return resultobj;
8478 fail:
8479 {
8480 if (temp2)
8481 delete arg2;
8482 }
8483 return NULL;
8484 }
8485
8486
8487 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8488 PyObject *resultobj;
8489 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8490 wxString *arg2 = 0 ;
8491 wxString result;
8492 bool temp2 = false ;
8493 PyObject * obj0 = 0 ;
8494 PyObject * obj1 = 0 ;
8495 char *kwnames[] = {
8496 (char *) "self",(char *) "location", NULL
8497 };
8498
8499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8501 if (SWIG_arg_fail(1)) SWIG_fail;
8502 {
8503 arg2 = wxString_in_helper(obj1);
8504 if (arg2 == NULL) SWIG_fail;
8505 temp2 = true;
8506 }
8507 {
8508 PyThreadState* __tstate = wxPyBeginAllowThreads();
8509 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8510
8511 wxPyEndAllowThreads(__tstate);
8512 if (PyErr_Occurred()) SWIG_fail;
8513 }
8514 {
8515 #if wxUSE_UNICODE
8516 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8517 #else
8518 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8519 #endif
8520 }
8521 {
8522 if (temp2)
8523 delete arg2;
8524 }
8525 return resultobj;
8526 fail:
8527 {
8528 if (temp2)
8529 delete arg2;
8530 }
8531 return NULL;
8532 }
8533
8534
8535 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8536 PyObject *resultobj;
8537 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8538 wxString *arg2 = 0 ;
8539 wxString result;
8540 bool temp2 = false ;
8541 PyObject * obj0 = 0 ;
8542 PyObject * obj1 = 0 ;
8543 char *kwnames[] = {
8544 (char *) "self",(char *) "location", NULL
8545 };
8546
8547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8549 if (SWIG_arg_fail(1)) SWIG_fail;
8550 {
8551 arg2 = wxString_in_helper(obj1);
8552 if (arg2 == NULL) SWIG_fail;
8553 temp2 = true;
8554 }
8555 {
8556 PyThreadState* __tstate = wxPyBeginAllowThreads();
8557 result = (arg1)->GetAnchor((wxString const &)*arg2);
8558
8559 wxPyEndAllowThreads(__tstate);
8560 if (PyErr_Occurred()) SWIG_fail;
8561 }
8562 {
8563 #if wxUSE_UNICODE
8564 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8565 #else
8566 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8567 #endif
8568 }
8569 {
8570 if (temp2)
8571 delete arg2;
8572 }
8573 return resultobj;
8574 fail:
8575 {
8576 if (temp2)
8577 delete arg2;
8578 }
8579 return NULL;
8580 }
8581
8582
8583 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8584 PyObject *resultobj;
8585 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8586 wxString *arg2 = 0 ;
8587 wxString result;
8588 bool temp2 = false ;
8589 PyObject * obj0 = 0 ;
8590 PyObject * obj1 = 0 ;
8591 char *kwnames[] = {
8592 (char *) "self",(char *) "location", NULL
8593 };
8594
8595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8597 if (SWIG_arg_fail(1)) SWIG_fail;
8598 {
8599 arg2 = wxString_in_helper(obj1);
8600 if (arg2 == NULL) SWIG_fail;
8601 temp2 = true;
8602 }
8603 {
8604 PyThreadState* __tstate = wxPyBeginAllowThreads();
8605 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8606
8607 wxPyEndAllowThreads(__tstate);
8608 if (PyErr_Occurred()) SWIG_fail;
8609 }
8610 {
8611 #if wxUSE_UNICODE
8612 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8613 #else
8614 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8615 #endif
8616 }
8617 {
8618 if (temp2)
8619 delete arg2;
8620 }
8621 return resultobj;
8622 fail:
8623 {
8624 if (temp2)
8625 delete arg2;
8626 }
8627 return NULL;
8628 }
8629
8630
8631 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8632 PyObject *resultobj;
8633 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8634 wxString *arg2 = 0 ;
8635 wxString result;
8636 bool temp2 = false ;
8637 PyObject * obj0 = 0 ;
8638 PyObject * obj1 = 0 ;
8639 char *kwnames[] = {
8640 (char *) "self",(char *) "location", NULL
8641 };
8642
8643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8645 if (SWIG_arg_fail(1)) SWIG_fail;
8646 {
8647 arg2 = wxString_in_helper(obj1);
8648 if (arg2 == NULL) SWIG_fail;
8649 temp2 = true;
8650 }
8651 {
8652 PyThreadState* __tstate = wxPyBeginAllowThreads();
8653 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8654
8655 wxPyEndAllowThreads(__tstate);
8656 if (PyErr_Occurred()) SWIG_fail;
8657 }
8658 {
8659 #if wxUSE_UNICODE
8660 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8661 #else
8662 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8663 #endif
8664 }
8665 {
8666 if (temp2)
8667 delete arg2;
8668 }
8669 return resultobj;
8670 fail:
8671 {
8672 if (temp2)
8673 delete arg2;
8674 }
8675 return NULL;
8676 }
8677
8678
8679 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8680 PyObject *obj;
8681 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8682 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8683 Py_INCREF(obj);
8684 return Py_BuildValue((char *)"");
8685 }
8686 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8687 PyObject *resultobj;
8688 wxFileSystem *result;
8689 char *kwnames[] = {
8690 NULL
8691 };
8692
8693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8694 {
8695 PyThreadState* __tstate = wxPyBeginAllowThreads();
8696 result = (wxFileSystem *)new wxFileSystem();
8697
8698 wxPyEndAllowThreads(__tstate);
8699 if (PyErr_Occurred()) SWIG_fail;
8700 }
8701 {
8702 resultobj = wxPyMake_wxObject(result, 1);
8703 }
8704 return resultobj;
8705 fail:
8706 return NULL;
8707 }
8708
8709
8710 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8711 PyObject *resultobj;
8712 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8713 PyObject * obj0 = 0 ;
8714 char *kwnames[] = {
8715 (char *) "self", NULL
8716 };
8717
8718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8720 if (SWIG_arg_fail(1)) SWIG_fail;
8721 {
8722 PyThreadState* __tstate = wxPyBeginAllowThreads();
8723 delete arg1;
8724
8725 wxPyEndAllowThreads(__tstate);
8726 if (PyErr_Occurred()) SWIG_fail;
8727 }
8728 Py_INCREF(Py_None); resultobj = Py_None;
8729 return resultobj;
8730 fail:
8731 return NULL;
8732 }
8733
8734
8735 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8736 PyObject *resultobj;
8737 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8738 wxString *arg2 = 0 ;
8739 bool arg3 = (bool) false ;
8740 bool temp2 = false ;
8741 PyObject * obj0 = 0 ;
8742 PyObject * obj1 = 0 ;
8743 PyObject * obj2 = 0 ;
8744 char *kwnames[] = {
8745 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8746 };
8747
8748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8750 if (SWIG_arg_fail(1)) SWIG_fail;
8751 {
8752 arg2 = wxString_in_helper(obj1);
8753 if (arg2 == NULL) SWIG_fail;
8754 temp2 = true;
8755 }
8756 if (obj2) {
8757 {
8758 arg3 = (bool)(SWIG_As_bool(obj2));
8759 if (SWIG_arg_fail(3)) SWIG_fail;
8760 }
8761 }
8762 {
8763 PyThreadState* __tstate = wxPyBeginAllowThreads();
8764 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8765
8766 wxPyEndAllowThreads(__tstate);
8767 if (PyErr_Occurred()) SWIG_fail;
8768 }
8769 Py_INCREF(Py_None); resultobj = Py_None;
8770 {
8771 if (temp2)
8772 delete arg2;
8773 }
8774 return resultobj;
8775 fail:
8776 {
8777 if (temp2)
8778 delete arg2;
8779 }
8780 return NULL;
8781 }
8782
8783
8784 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8785 PyObject *resultobj;
8786 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8787 wxString result;
8788 PyObject * obj0 = 0 ;
8789 char *kwnames[] = {
8790 (char *) "self", NULL
8791 };
8792
8793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8795 if (SWIG_arg_fail(1)) SWIG_fail;
8796 {
8797 PyThreadState* __tstate = wxPyBeginAllowThreads();
8798 result = (arg1)->GetPath();
8799
8800 wxPyEndAllowThreads(__tstate);
8801 if (PyErr_Occurred()) SWIG_fail;
8802 }
8803 {
8804 #if wxUSE_UNICODE
8805 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8806 #else
8807 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8808 #endif
8809 }
8810 return resultobj;
8811 fail:
8812 return NULL;
8813 }
8814
8815
8816 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8817 PyObject *resultobj;
8818 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8819 wxString *arg2 = 0 ;
8820 wxFSFile *result;
8821 bool temp2 = false ;
8822 PyObject * obj0 = 0 ;
8823 PyObject * obj1 = 0 ;
8824 char *kwnames[] = {
8825 (char *) "self",(char *) "location", NULL
8826 };
8827
8828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8830 if (SWIG_arg_fail(1)) SWIG_fail;
8831 {
8832 arg2 = wxString_in_helper(obj1);
8833 if (arg2 == NULL) SWIG_fail;
8834 temp2 = true;
8835 }
8836 {
8837 PyThreadState* __tstate = wxPyBeginAllowThreads();
8838 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8839
8840 wxPyEndAllowThreads(__tstate);
8841 if (PyErr_Occurred()) SWIG_fail;
8842 }
8843 {
8844 resultobj = wxPyMake_wxObject(result, 1);
8845 }
8846 {
8847 if (temp2)
8848 delete arg2;
8849 }
8850 return resultobj;
8851 fail:
8852 {
8853 if (temp2)
8854 delete arg2;
8855 }
8856 return NULL;
8857 }
8858
8859
8860 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8861 PyObject *resultobj;
8862 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8863 wxString *arg2 = 0 ;
8864 int arg3 = (int) 0 ;
8865 wxString result;
8866 bool temp2 = false ;
8867 PyObject * obj0 = 0 ;
8868 PyObject * obj1 = 0 ;
8869 PyObject * obj2 = 0 ;
8870 char *kwnames[] = {
8871 (char *) "self",(char *) "spec",(char *) "flags", NULL
8872 };
8873
8874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8876 if (SWIG_arg_fail(1)) SWIG_fail;
8877 {
8878 arg2 = wxString_in_helper(obj1);
8879 if (arg2 == NULL) SWIG_fail;
8880 temp2 = true;
8881 }
8882 if (obj2) {
8883 {
8884 arg3 = (int)(SWIG_As_int(obj2));
8885 if (SWIG_arg_fail(3)) SWIG_fail;
8886 }
8887 }
8888 {
8889 PyThreadState* __tstate = wxPyBeginAllowThreads();
8890 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8891
8892 wxPyEndAllowThreads(__tstate);
8893 if (PyErr_Occurred()) SWIG_fail;
8894 }
8895 {
8896 #if wxUSE_UNICODE
8897 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8898 #else
8899 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8900 #endif
8901 }
8902 {
8903 if (temp2)
8904 delete arg2;
8905 }
8906 return resultobj;
8907 fail:
8908 {
8909 if (temp2)
8910 delete arg2;
8911 }
8912 return NULL;
8913 }
8914
8915
8916 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8917 PyObject *resultobj;
8918 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8919 wxString result;
8920 PyObject * obj0 = 0 ;
8921 char *kwnames[] = {
8922 (char *) "self", NULL
8923 };
8924
8925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8927 if (SWIG_arg_fail(1)) SWIG_fail;
8928 {
8929 PyThreadState* __tstate = wxPyBeginAllowThreads();
8930 result = (arg1)->FindNext();
8931
8932 wxPyEndAllowThreads(__tstate);
8933 if (PyErr_Occurred()) SWIG_fail;
8934 }
8935 {
8936 #if wxUSE_UNICODE
8937 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8938 #else
8939 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8940 #endif
8941 }
8942 return resultobj;
8943 fail:
8944 return NULL;
8945 }
8946
8947
8948 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8949 PyObject *resultobj;
8950 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8951 PyObject * obj0 = 0 ;
8952 char *kwnames[] = {
8953 (char *) "handler", NULL
8954 };
8955
8956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8958 if (SWIG_arg_fail(1)) SWIG_fail;
8959 {
8960 PyThreadState* __tstate = wxPyBeginAllowThreads();
8961 wxFileSystem::AddHandler(arg1);
8962
8963 wxPyEndAllowThreads(__tstate);
8964 if (PyErr_Occurred()) SWIG_fail;
8965 }
8966 Py_INCREF(Py_None); resultobj = Py_None;
8967 return resultobj;
8968 fail:
8969 return NULL;
8970 }
8971
8972
8973 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
8974 PyObject *resultobj;
8975 char *kwnames[] = {
8976 NULL
8977 };
8978
8979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
8980 {
8981 PyThreadState* __tstate = wxPyBeginAllowThreads();
8982 wxFileSystem::CleanUpHandlers();
8983
8984 wxPyEndAllowThreads(__tstate);
8985 if (PyErr_Occurred()) SWIG_fail;
8986 }
8987 Py_INCREF(Py_None); resultobj = Py_None;
8988 return resultobj;
8989 fail:
8990 return NULL;
8991 }
8992
8993
8994 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
8995 PyObject *resultobj;
8996 wxString *arg1 = 0 ;
8997 wxString result;
8998 bool temp1 = false ;
8999 PyObject * obj0 = 0 ;
9000 char *kwnames[] = {
9001 (char *) "filename", NULL
9002 };
9003
9004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9005 {
9006 arg1 = wxString_in_helper(obj0);
9007 if (arg1 == NULL) SWIG_fail;
9008 temp1 = true;
9009 }
9010 {
9011 PyThreadState* __tstate = wxPyBeginAllowThreads();
9012 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9013
9014 wxPyEndAllowThreads(__tstate);
9015 if (PyErr_Occurred()) SWIG_fail;
9016 }
9017 {
9018 #if wxUSE_UNICODE
9019 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9020 #else
9021 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9022 #endif
9023 }
9024 {
9025 if (temp1)
9026 delete arg1;
9027 }
9028 return resultobj;
9029 fail:
9030 {
9031 if (temp1)
9032 delete arg1;
9033 }
9034 return NULL;
9035 }
9036
9037
9038 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9039 PyObject *resultobj;
9040 wxString *arg1 = 0 ;
9041 wxString result;
9042 bool temp1 = false ;
9043 PyObject * obj0 = 0 ;
9044 char *kwnames[] = {
9045 (char *) "url", NULL
9046 };
9047
9048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9049 {
9050 arg1 = wxString_in_helper(obj0);
9051 if (arg1 == NULL) SWIG_fail;
9052 temp1 = true;
9053 }
9054 {
9055 PyThreadState* __tstate = wxPyBeginAllowThreads();
9056 result = FileSystem_URLToFileName((wxString const &)*arg1);
9057
9058 wxPyEndAllowThreads(__tstate);
9059 if (PyErr_Occurred()) SWIG_fail;
9060 }
9061 {
9062 #if wxUSE_UNICODE
9063 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9064 #else
9065 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9066 #endif
9067 }
9068 {
9069 if (temp1)
9070 delete arg1;
9071 }
9072 return resultobj;
9073 fail:
9074 {
9075 if (temp1)
9076 delete arg1;
9077 }
9078 return NULL;
9079 }
9080
9081
9082 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9083 PyObject *obj;
9084 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9085 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9086 Py_INCREF(obj);
9087 return Py_BuildValue((char *)"");
9088 }
9089 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9090 PyObject *resultobj;
9091 wxInternetFSHandler *result;
9092 char *kwnames[] = {
9093 NULL
9094 };
9095
9096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9097 {
9098 PyThreadState* __tstate = wxPyBeginAllowThreads();
9099 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9100
9101 wxPyEndAllowThreads(__tstate);
9102 if (PyErr_Occurred()) SWIG_fail;
9103 }
9104 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9105 return resultobj;
9106 fail:
9107 return NULL;
9108 }
9109
9110
9111 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9112 PyObject *resultobj;
9113 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9114 wxString *arg2 = 0 ;
9115 bool result;
9116 bool temp2 = false ;
9117 PyObject * obj0 = 0 ;
9118 PyObject * obj1 = 0 ;
9119 char *kwnames[] = {
9120 (char *) "self",(char *) "location", NULL
9121 };
9122
9123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9125 if (SWIG_arg_fail(1)) SWIG_fail;
9126 {
9127 arg2 = wxString_in_helper(obj1);
9128 if (arg2 == NULL) SWIG_fail;
9129 temp2 = true;
9130 }
9131 {
9132 PyThreadState* __tstate = wxPyBeginAllowThreads();
9133 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9134
9135 wxPyEndAllowThreads(__tstate);
9136 if (PyErr_Occurred()) SWIG_fail;
9137 }
9138 {
9139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9140 }
9141 {
9142 if (temp2)
9143 delete arg2;
9144 }
9145 return resultobj;
9146 fail:
9147 {
9148 if (temp2)
9149 delete arg2;
9150 }
9151 return NULL;
9152 }
9153
9154
9155 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9156 PyObject *resultobj;
9157 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9158 wxFileSystem *arg2 = 0 ;
9159 wxString *arg3 = 0 ;
9160 wxFSFile *result;
9161 bool temp3 = false ;
9162 PyObject * obj0 = 0 ;
9163 PyObject * obj1 = 0 ;
9164 PyObject * obj2 = 0 ;
9165 char *kwnames[] = {
9166 (char *) "self",(char *) "fs",(char *) "location", NULL
9167 };
9168
9169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9171 if (SWIG_arg_fail(1)) SWIG_fail;
9172 {
9173 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9174 if (SWIG_arg_fail(2)) SWIG_fail;
9175 if (arg2 == NULL) {
9176 SWIG_null_ref("wxFileSystem");
9177 }
9178 if (SWIG_arg_fail(2)) SWIG_fail;
9179 }
9180 {
9181 arg3 = wxString_in_helper(obj2);
9182 if (arg3 == NULL) SWIG_fail;
9183 temp3 = true;
9184 }
9185 {
9186 PyThreadState* __tstate = wxPyBeginAllowThreads();
9187 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9188
9189 wxPyEndAllowThreads(__tstate);
9190 if (PyErr_Occurred()) SWIG_fail;
9191 }
9192 {
9193 resultobj = wxPyMake_wxObject(result, 1);
9194 }
9195 {
9196 if (temp3)
9197 delete arg3;
9198 }
9199 return resultobj;
9200 fail:
9201 {
9202 if (temp3)
9203 delete arg3;
9204 }
9205 return NULL;
9206 }
9207
9208
9209 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9210 PyObject *obj;
9211 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9212 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9213 Py_INCREF(obj);
9214 return Py_BuildValue((char *)"");
9215 }
9216 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9217 PyObject *resultobj;
9218 wxZipFSHandler *result;
9219 char *kwnames[] = {
9220 NULL
9221 };
9222
9223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9224 {
9225 PyThreadState* __tstate = wxPyBeginAllowThreads();
9226 result = (wxZipFSHandler *)new wxZipFSHandler();
9227
9228 wxPyEndAllowThreads(__tstate);
9229 if (PyErr_Occurred()) SWIG_fail;
9230 }
9231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9232 return resultobj;
9233 fail:
9234 return NULL;
9235 }
9236
9237
9238 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9239 PyObject *resultobj;
9240 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9241 wxString *arg2 = 0 ;
9242 bool result;
9243 bool temp2 = false ;
9244 PyObject * obj0 = 0 ;
9245 PyObject * obj1 = 0 ;
9246 char *kwnames[] = {
9247 (char *) "self",(char *) "location", NULL
9248 };
9249
9250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9252 if (SWIG_arg_fail(1)) SWIG_fail;
9253 {
9254 arg2 = wxString_in_helper(obj1);
9255 if (arg2 == NULL) SWIG_fail;
9256 temp2 = true;
9257 }
9258 {
9259 PyThreadState* __tstate = wxPyBeginAllowThreads();
9260 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9261
9262 wxPyEndAllowThreads(__tstate);
9263 if (PyErr_Occurred()) SWIG_fail;
9264 }
9265 {
9266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9267 }
9268 {
9269 if (temp2)
9270 delete arg2;
9271 }
9272 return resultobj;
9273 fail:
9274 {
9275 if (temp2)
9276 delete arg2;
9277 }
9278 return NULL;
9279 }
9280
9281
9282 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9283 PyObject *resultobj;
9284 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9285 wxFileSystem *arg2 = 0 ;
9286 wxString *arg3 = 0 ;
9287 wxFSFile *result;
9288 bool temp3 = false ;
9289 PyObject * obj0 = 0 ;
9290 PyObject * obj1 = 0 ;
9291 PyObject * obj2 = 0 ;
9292 char *kwnames[] = {
9293 (char *) "self",(char *) "fs",(char *) "location", NULL
9294 };
9295
9296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9298 if (SWIG_arg_fail(1)) SWIG_fail;
9299 {
9300 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9301 if (SWIG_arg_fail(2)) SWIG_fail;
9302 if (arg2 == NULL) {
9303 SWIG_null_ref("wxFileSystem");
9304 }
9305 if (SWIG_arg_fail(2)) SWIG_fail;
9306 }
9307 {
9308 arg3 = wxString_in_helper(obj2);
9309 if (arg3 == NULL) SWIG_fail;
9310 temp3 = true;
9311 }
9312 {
9313 PyThreadState* __tstate = wxPyBeginAllowThreads();
9314 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9315
9316 wxPyEndAllowThreads(__tstate);
9317 if (PyErr_Occurred()) SWIG_fail;
9318 }
9319 {
9320 resultobj = wxPyMake_wxObject(result, 1);
9321 }
9322 {
9323 if (temp3)
9324 delete arg3;
9325 }
9326 return resultobj;
9327 fail:
9328 {
9329 if (temp3)
9330 delete arg3;
9331 }
9332 return NULL;
9333 }
9334
9335
9336 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9337 PyObject *resultobj;
9338 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9339 wxString *arg2 = 0 ;
9340 int arg3 = (int) 0 ;
9341 wxString result;
9342 bool temp2 = false ;
9343 PyObject * obj0 = 0 ;
9344 PyObject * obj1 = 0 ;
9345 PyObject * obj2 = 0 ;
9346 char *kwnames[] = {
9347 (char *) "self",(char *) "spec",(char *) "flags", NULL
9348 };
9349
9350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9352 if (SWIG_arg_fail(1)) SWIG_fail;
9353 {
9354 arg2 = wxString_in_helper(obj1);
9355 if (arg2 == NULL) SWIG_fail;
9356 temp2 = true;
9357 }
9358 if (obj2) {
9359 {
9360 arg3 = (int)(SWIG_As_int(obj2));
9361 if (SWIG_arg_fail(3)) SWIG_fail;
9362 }
9363 }
9364 {
9365 PyThreadState* __tstate = wxPyBeginAllowThreads();
9366 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9367
9368 wxPyEndAllowThreads(__tstate);
9369 if (PyErr_Occurred()) SWIG_fail;
9370 }
9371 {
9372 #if wxUSE_UNICODE
9373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9374 #else
9375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9376 #endif
9377 }
9378 {
9379 if (temp2)
9380 delete arg2;
9381 }
9382 return resultobj;
9383 fail:
9384 {
9385 if (temp2)
9386 delete arg2;
9387 }
9388 return NULL;
9389 }
9390
9391
9392 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9393 PyObject *resultobj;
9394 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9395 wxString result;
9396 PyObject * obj0 = 0 ;
9397 char *kwnames[] = {
9398 (char *) "self", NULL
9399 };
9400
9401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9403 if (SWIG_arg_fail(1)) SWIG_fail;
9404 {
9405 PyThreadState* __tstate = wxPyBeginAllowThreads();
9406 result = (arg1)->FindNext();
9407
9408 wxPyEndAllowThreads(__tstate);
9409 if (PyErr_Occurred()) SWIG_fail;
9410 }
9411 {
9412 #if wxUSE_UNICODE
9413 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9414 #else
9415 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9416 #endif
9417 }
9418 return resultobj;
9419 fail:
9420 return NULL;
9421 }
9422
9423
9424 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9425 PyObject *obj;
9426 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9427 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9428 Py_INCREF(obj);
9429 return Py_BuildValue((char *)"");
9430 }
9431 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9432 PyObject *resultobj;
9433 wxString *arg1 = 0 ;
9434 wxImage *arg2 = 0 ;
9435 long arg3 ;
9436 bool temp1 = false ;
9437 PyObject * obj0 = 0 ;
9438 PyObject * obj1 = 0 ;
9439 PyObject * obj2 = 0 ;
9440 char *kwnames[] = {
9441 (char *) "filename",(char *) "image",(char *) "type", NULL
9442 };
9443
9444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9445 {
9446 arg1 = wxString_in_helper(obj0);
9447 if (arg1 == NULL) SWIG_fail;
9448 temp1 = true;
9449 }
9450 {
9451 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9452 if (SWIG_arg_fail(2)) SWIG_fail;
9453 if (arg2 == NULL) {
9454 SWIG_null_ref("wxImage");
9455 }
9456 if (SWIG_arg_fail(2)) SWIG_fail;
9457 }
9458 {
9459 arg3 = (long)(SWIG_As_long(obj2));
9460 if (SWIG_arg_fail(3)) SWIG_fail;
9461 }
9462 {
9463 PyThreadState* __tstate = wxPyBeginAllowThreads();
9464 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9465
9466 wxPyEndAllowThreads(__tstate);
9467 if (PyErr_Occurred()) SWIG_fail;
9468 }
9469 Py_INCREF(Py_None); resultobj = Py_None;
9470 {
9471 if (temp1)
9472 delete arg1;
9473 }
9474 return resultobj;
9475 fail:
9476 {
9477 if (temp1)
9478 delete arg1;
9479 }
9480 return NULL;
9481 }
9482
9483
9484 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9485 PyObject *resultobj;
9486 wxString *arg1 = 0 ;
9487 wxBitmap *arg2 = 0 ;
9488 long arg3 ;
9489 bool temp1 = false ;
9490 PyObject * obj0 = 0 ;
9491 PyObject * obj1 = 0 ;
9492 PyObject * obj2 = 0 ;
9493 char *kwnames[] = {
9494 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9495 };
9496
9497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9498 {
9499 arg1 = wxString_in_helper(obj0);
9500 if (arg1 == NULL) SWIG_fail;
9501 temp1 = true;
9502 }
9503 {
9504 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9505 if (SWIG_arg_fail(2)) SWIG_fail;
9506 if (arg2 == NULL) {
9507 SWIG_null_ref("wxBitmap");
9508 }
9509 if (SWIG_arg_fail(2)) SWIG_fail;
9510 }
9511 {
9512 arg3 = (long)(SWIG_As_long(obj2));
9513 if (SWIG_arg_fail(3)) SWIG_fail;
9514 }
9515 {
9516 PyThreadState* __tstate = wxPyBeginAllowThreads();
9517 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9518
9519 wxPyEndAllowThreads(__tstate);
9520 if (PyErr_Occurred()) SWIG_fail;
9521 }
9522 Py_INCREF(Py_None); resultobj = Py_None;
9523 {
9524 if (temp1)
9525 delete arg1;
9526 }
9527 return resultobj;
9528 fail:
9529 {
9530 if (temp1)
9531 delete arg1;
9532 }
9533 return NULL;
9534 }
9535
9536
9537 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9538 PyObject *resultobj;
9539 wxString *arg1 = 0 ;
9540 PyObject *arg2 = (PyObject *) 0 ;
9541 bool temp1 = false ;
9542 PyObject * obj0 = 0 ;
9543 PyObject * obj1 = 0 ;
9544 char *kwnames[] = {
9545 (char *) "filename",(char *) "data", NULL
9546 };
9547
9548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9549 {
9550 arg1 = wxString_in_helper(obj0);
9551 if (arg1 == NULL) SWIG_fail;
9552 temp1 = true;
9553 }
9554 arg2 = obj1;
9555 {
9556 PyThreadState* __tstate = wxPyBeginAllowThreads();
9557 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9558
9559 wxPyEndAllowThreads(__tstate);
9560 if (PyErr_Occurred()) SWIG_fail;
9561 }
9562 Py_INCREF(Py_None); resultobj = Py_None;
9563 {
9564 if (temp1)
9565 delete arg1;
9566 }
9567 return resultobj;
9568 fail:
9569 {
9570 if (temp1)
9571 delete arg1;
9572 }
9573 return NULL;
9574 }
9575
9576
9577 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9578 PyObject *resultobj;
9579 wxMemoryFSHandler *result;
9580 char *kwnames[] = {
9581 NULL
9582 };
9583
9584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9585 {
9586 PyThreadState* __tstate = wxPyBeginAllowThreads();
9587 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9588
9589 wxPyEndAllowThreads(__tstate);
9590 if (PyErr_Occurred()) SWIG_fail;
9591 }
9592 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9593 return resultobj;
9594 fail:
9595 return NULL;
9596 }
9597
9598
9599 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9600 PyObject *resultobj;
9601 wxString *arg1 = 0 ;
9602 bool temp1 = false ;
9603 PyObject * obj0 = 0 ;
9604 char *kwnames[] = {
9605 (char *) "filename", NULL
9606 };
9607
9608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9609 {
9610 arg1 = wxString_in_helper(obj0);
9611 if (arg1 == NULL) SWIG_fail;
9612 temp1 = true;
9613 }
9614 {
9615 PyThreadState* __tstate = wxPyBeginAllowThreads();
9616 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9617
9618 wxPyEndAllowThreads(__tstate);
9619 if (PyErr_Occurred()) SWIG_fail;
9620 }
9621 Py_INCREF(Py_None); resultobj = Py_None;
9622 {
9623 if (temp1)
9624 delete arg1;
9625 }
9626 return resultobj;
9627 fail:
9628 {
9629 if (temp1)
9630 delete arg1;
9631 }
9632 return NULL;
9633 }
9634
9635
9636 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9637 PyObject *resultobj;
9638 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9639 wxString *arg2 = 0 ;
9640 bool result;
9641 bool temp2 = false ;
9642 PyObject * obj0 = 0 ;
9643 PyObject * obj1 = 0 ;
9644 char *kwnames[] = {
9645 (char *) "self",(char *) "location", NULL
9646 };
9647
9648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9650 if (SWIG_arg_fail(1)) SWIG_fail;
9651 {
9652 arg2 = wxString_in_helper(obj1);
9653 if (arg2 == NULL) SWIG_fail;
9654 temp2 = true;
9655 }
9656 {
9657 PyThreadState* __tstate = wxPyBeginAllowThreads();
9658 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9659
9660 wxPyEndAllowThreads(__tstate);
9661 if (PyErr_Occurred()) SWIG_fail;
9662 }
9663 {
9664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9665 }
9666 {
9667 if (temp2)
9668 delete arg2;
9669 }
9670 return resultobj;
9671 fail:
9672 {
9673 if (temp2)
9674 delete arg2;
9675 }
9676 return NULL;
9677 }
9678
9679
9680 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9681 PyObject *resultobj;
9682 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9683 wxFileSystem *arg2 = 0 ;
9684 wxString *arg3 = 0 ;
9685 wxFSFile *result;
9686 bool temp3 = false ;
9687 PyObject * obj0 = 0 ;
9688 PyObject * obj1 = 0 ;
9689 PyObject * obj2 = 0 ;
9690 char *kwnames[] = {
9691 (char *) "self",(char *) "fs",(char *) "location", NULL
9692 };
9693
9694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9696 if (SWIG_arg_fail(1)) SWIG_fail;
9697 {
9698 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9699 if (SWIG_arg_fail(2)) SWIG_fail;
9700 if (arg2 == NULL) {
9701 SWIG_null_ref("wxFileSystem");
9702 }
9703 if (SWIG_arg_fail(2)) SWIG_fail;
9704 }
9705 {
9706 arg3 = wxString_in_helper(obj2);
9707 if (arg3 == NULL) SWIG_fail;
9708 temp3 = true;
9709 }
9710 {
9711 PyThreadState* __tstate = wxPyBeginAllowThreads();
9712 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9713
9714 wxPyEndAllowThreads(__tstate);
9715 if (PyErr_Occurred()) SWIG_fail;
9716 }
9717 {
9718 resultobj = wxPyMake_wxObject(result, 1);
9719 }
9720 {
9721 if (temp3)
9722 delete arg3;
9723 }
9724 return resultobj;
9725 fail:
9726 {
9727 if (temp3)
9728 delete arg3;
9729 }
9730 return NULL;
9731 }
9732
9733
9734 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9735 PyObject *resultobj;
9736 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9737 wxString *arg2 = 0 ;
9738 int arg3 = (int) 0 ;
9739 wxString result;
9740 bool temp2 = false ;
9741 PyObject * obj0 = 0 ;
9742 PyObject * obj1 = 0 ;
9743 PyObject * obj2 = 0 ;
9744 char *kwnames[] = {
9745 (char *) "self",(char *) "spec",(char *) "flags", NULL
9746 };
9747
9748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9750 if (SWIG_arg_fail(1)) SWIG_fail;
9751 {
9752 arg2 = wxString_in_helper(obj1);
9753 if (arg2 == NULL) SWIG_fail;
9754 temp2 = true;
9755 }
9756 if (obj2) {
9757 {
9758 arg3 = (int)(SWIG_As_int(obj2));
9759 if (SWIG_arg_fail(3)) SWIG_fail;
9760 }
9761 }
9762 {
9763 PyThreadState* __tstate = wxPyBeginAllowThreads();
9764 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9765
9766 wxPyEndAllowThreads(__tstate);
9767 if (PyErr_Occurred()) SWIG_fail;
9768 }
9769 {
9770 #if wxUSE_UNICODE
9771 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9772 #else
9773 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9774 #endif
9775 }
9776 {
9777 if (temp2)
9778 delete arg2;
9779 }
9780 return resultobj;
9781 fail:
9782 {
9783 if (temp2)
9784 delete arg2;
9785 }
9786 return NULL;
9787 }
9788
9789
9790 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9791 PyObject *resultobj;
9792 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9793 wxString result;
9794 PyObject * obj0 = 0 ;
9795 char *kwnames[] = {
9796 (char *) "self", NULL
9797 };
9798
9799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9801 if (SWIG_arg_fail(1)) SWIG_fail;
9802 {
9803 PyThreadState* __tstate = wxPyBeginAllowThreads();
9804 result = (arg1)->FindNext();
9805
9806 wxPyEndAllowThreads(__tstate);
9807 if (PyErr_Occurred()) SWIG_fail;
9808 }
9809 {
9810 #if wxUSE_UNICODE
9811 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9812 #else
9813 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9814 #endif
9815 }
9816 return resultobj;
9817 fail:
9818 return NULL;
9819 }
9820
9821
9822 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9823 PyObject *obj;
9824 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9825 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9826 Py_INCREF(obj);
9827 return Py_BuildValue((char *)"");
9828 }
9829 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9830 PyObject *resultobj;
9831 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9832 wxString result;
9833 PyObject * obj0 = 0 ;
9834 char *kwnames[] = {
9835 (char *) "self", NULL
9836 };
9837
9838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9840 if (SWIG_arg_fail(1)) SWIG_fail;
9841 {
9842 PyThreadState* __tstate = wxPyBeginAllowThreads();
9843 result = (arg1)->GetName();
9844
9845 wxPyEndAllowThreads(__tstate);
9846 if (PyErr_Occurred()) SWIG_fail;
9847 }
9848 {
9849 #if wxUSE_UNICODE
9850 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9851 #else
9852 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9853 #endif
9854 }
9855 return resultobj;
9856 fail:
9857 return NULL;
9858 }
9859
9860
9861 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9862 PyObject *resultobj;
9863 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9864 wxString result;
9865 PyObject * obj0 = 0 ;
9866 char *kwnames[] = {
9867 (char *) "self", NULL
9868 };
9869
9870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9872 if (SWIG_arg_fail(1)) SWIG_fail;
9873 {
9874 PyThreadState* __tstate = wxPyBeginAllowThreads();
9875 result = (arg1)->GetExtension();
9876
9877 wxPyEndAllowThreads(__tstate);
9878 if (PyErr_Occurred()) SWIG_fail;
9879 }
9880 {
9881 #if wxUSE_UNICODE
9882 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9883 #else
9884 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9885 #endif
9886 }
9887 return resultobj;
9888 fail:
9889 return NULL;
9890 }
9891
9892
9893 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9894 PyObject *resultobj;
9895 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9896 long result;
9897 PyObject * obj0 = 0 ;
9898 char *kwnames[] = {
9899 (char *) "self", NULL
9900 };
9901
9902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9904 if (SWIG_arg_fail(1)) SWIG_fail;
9905 {
9906 PyThreadState* __tstate = wxPyBeginAllowThreads();
9907 result = (long)(arg1)->GetType();
9908
9909 wxPyEndAllowThreads(__tstate);
9910 if (PyErr_Occurred()) SWIG_fail;
9911 }
9912 {
9913 resultobj = SWIG_From_long((long)(result));
9914 }
9915 return resultobj;
9916 fail:
9917 return NULL;
9918 }
9919
9920
9921 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9922 PyObject *resultobj;
9923 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9924 wxString result;
9925 PyObject * obj0 = 0 ;
9926 char *kwnames[] = {
9927 (char *) "self", NULL
9928 };
9929
9930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9932 if (SWIG_arg_fail(1)) SWIG_fail;
9933 {
9934 PyThreadState* __tstate = wxPyBeginAllowThreads();
9935 result = (arg1)->GetMimeType();
9936
9937 wxPyEndAllowThreads(__tstate);
9938 if (PyErr_Occurred()) SWIG_fail;
9939 }
9940 {
9941 #if wxUSE_UNICODE
9942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9943 #else
9944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9945 #endif
9946 }
9947 return resultobj;
9948 fail:
9949 return NULL;
9950 }
9951
9952
9953 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9954 PyObject *resultobj;
9955 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9956 wxString *arg2 = 0 ;
9957 bool result;
9958 bool temp2 = false ;
9959 PyObject * obj0 = 0 ;
9960 PyObject * obj1 = 0 ;
9961 char *kwnames[] = {
9962 (char *) "self",(char *) "name", NULL
9963 };
9964
9965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
9966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9967 if (SWIG_arg_fail(1)) SWIG_fail;
9968 {
9969 arg2 = wxString_in_helper(obj1);
9970 if (arg2 == NULL) SWIG_fail;
9971 temp2 = true;
9972 }
9973 {
9974 PyThreadState* __tstate = wxPyBeginAllowThreads();
9975 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
9976
9977 wxPyEndAllowThreads(__tstate);
9978 if (PyErr_Occurred()) SWIG_fail;
9979 }
9980 {
9981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9982 }
9983 {
9984 if (temp2)
9985 delete arg2;
9986 }
9987 return resultobj;
9988 fail:
9989 {
9990 if (temp2)
9991 delete arg2;
9992 }
9993 return NULL;
9994 }
9995
9996
9997 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
9998 PyObject *resultobj;
9999 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10000 wxString *arg2 = 0 ;
10001 bool temp2 = false ;
10002 PyObject * obj0 = 0 ;
10003 PyObject * obj1 = 0 ;
10004 char *kwnames[] = {
10005 (char *) "self",(char *) "name", NULL
10006 };
10007
10008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10010 if (SWIG_arg_fail(1)) SWIG_fail;
10011 {
10012 arg2 = wxString_in_helper(obj1);
10013 if (arg2 == NULL) SWIG_fail;
10014 temp2 = true;
10015 }
10016 {
10017 PyThreadState* __tstate = wxPyBeginAllowThreads();
10018 (arg1)->SetName((wxString const &)*arg2);
10019
10020 wxPyEndAllowThreads(__tstate);
10021 if (PyErr_Occurred()) SWIG_fail;
10022 }
10023 Py_INCREF(Py_None); resultobj = Py_None;
10024 {
10025 if (temp2)
10026 delete arg2;
10027 }
10028 return resultobj;
10029 fail:
10030 {
10031 if (temp2)
10032 delete arg2;
10033 }
10034 return NULL;
10035 }
10036
10037
10038 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10039 PyObject *resultobj;
10040 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10041 wxString *arg2 = 0 ;
10042 bool temp2 = false ;
10043 PyObject * obj0 = 0 ;
10044 PyObject * obj1 = 0 ;
10045 char *kwnames[] = {
10046 (char *) "self",(char *) "extension", NULL
10047 };
10048
10049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10051 if (SWIG_arg_fail(1)) SWIG_fail;
10052 {
10053 arg2 = wxString_in_helper(obj1);
10054 if (arg2 == NULL) SWIG_fail;
10055 temp2 = true;
10056 }
10057 {
10058 PyThreadState* __tstate = wxPyBeginAllowThreads();
10059 (arg1)->SetExtension((wxString const &)*arg2);
10060
10061 wxPyEndAllowThreads(__tstate);
10062 if (PyErr_Occurred()) SWIG_fail;
10063 }
10064 Py_INCREF(Py_None); resultobj = Py_None;
10065 {
10066 if (temp2)
10067 delete arg2;
10068 }
10069 return resultobj;
10070 fail:
10071 {
10072 if (temp2)
10073 delete arg2;
10074 }
10075 return NULL;
10076 }
10077
10078
10079 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10080 PyObject *resultobj;
10081 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10082 long arg2 ;
10083 PyObject * obj0 = 0 ;
10084 PyObject * obj1 = 0 ;
10085 char *kwnames[] = {
10086 (char *) "self",(char *) "type", NULL
10087 };
10088
10089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10091 if (SWIG_arg_fail(1)) SWIG_fail;
10092 {
10093 arg2 = (long)(SWIG_As_long(obj1));
10094 if (SWIG_arg_fail(2)) SWIG_fail;
10095 }
10096 {
10097 PyThreadState* __tstate = wxPyBeginAllowThreads();
10098 (arg1)->SetType(arg2);
10099
10100 wxPyEndAllowThreads(__tstate);
10101 if (PyErr_Occurred()) SWIG_fail;
10102 }
10103 Py_INCREF(Py_None); resultobj = Py_None;
10104 return resultobj;
10105 fail:
10106 return NULL;
10107 }
10108
10109
10110 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10111 PyObject *resultobj;
10112 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10113 wxString *arg2 = 0 ;
10114 bool temp2 = false ;
10115 PyObject * obj0 = 0 ;
10116 PyObject * obj1 = 0 ;
10117 char *kwnames[] = {
10118 (char *) "self",(char *) "mimetype", NULL
10119 };
10120
10121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10123 if (SWIG_arg_fail(1)) SWIG_fail;
10124 {
10125 arg2 = wxString_in_helper(obj1);
10126 if (arg2 == NULL) SWIG_fail;
10127 temp2 = true;
10128 }
10129 {
10130 PyThreadState* __tstate = wxPyBeginAllowThreads();
10131 (arg1)->SetMimeType((wxString const &)*arg2);
10132
10133 wxPyEndAllowThreads(__tstate);
10134 if (PyErr_Occurred()) SWIG_fail;
10135 }
10136 Py_INCREF(Py_None); resultobj = Py_None;
10137 {
10138 if (temp2)
10139 delete arg2;
10140 }
10141 return resultobj;
10142 fail:
10143 {
10144 if (temp2)
10145 delete arg2;
10146 }
10147 return NULL;
10148 }
10149
10150
10151 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10152 PyObject *obj;
10153 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10154 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10155 Py_INCREF(obj);
10156 return Py_BuildValue((char *)"");
10157 }
10158 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10159 PyObject *resultobj;
10160 wxImageHistogram *result;
10161 char *kwnames[] = {
10162 NULL
10163 };
10164
10165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10166 {
10167 PyThreadState* __tstate = wxPyBeginAllowThreads();
10168 result = (wxImageHistogram *)new wxImageHistogram();
10169
10170 wxPyEndAllowThreads(__tstate);
10171 if (PyErr_Occurred()) SWIG_fail;
10172 }
10173 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10174 return resultobj;
10175 fail:
10176 return NULL;
10177 }
10178
10179
10180 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10181 PyObject *resultobj;
10182 unsigned char arg1 ;
10183 unsigned char arg2 ;
10184 unsigned char arg3 ;
10185 unsigned long result;
10186 PyObject * obj0 = 0 ;
10187 PyObject * obj1 = 0 ;
10188 PyObject * obj2 = 0 ;
10189 char *kwnames[] = {
10190 (char *) "r",(char *) "g",(char *) "b", NULL
10191 };
10192
10193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10194 {
10195 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10196 if (SWIG_arg_fail(1)) SWIG_fail;
10197 }
10198 {
10199 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10200 if (SWIG_arg_fail(2)) SWIG_fail;
10201 }
10202 {
10203 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10204 if (SWIG_arg_fail(3)) SWIG_fail;
10205 }
10206 {
10207 PyThreadState* __tstate = wxPyBeginAllowThreads();
10208 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10209
10210 wxPyEndAllowThreads(__tstate);
10211 if (PyErr_Occurred()) SWIG_fail;
10212 }
10213 {
10214 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10215 }
10216 return resultobj;
10217 fail:
10218 return NULL;
10219 }
10220
10221
10222 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10223 PyObject *resultobj;
10224 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10225 unsigned char *arg2 = (unsigned char *) 0 ;
10226 unsigned char *arg3 = (unsigned char *) 0 ;
10227 unsigned char *arg4 = (unsigned char *) 0 ;
10228 unsigned char arg5 = (unsigned char) 1 ;
10229 unsigned char arg6 = (unsigned char) 0 ;
10230 unsigned char arg7 = (unsigned char) 0 ;
10231 bool result;
10232 unsigned char temp2 ;
10233 int res2 = 0 ;
10234 unsigned char temp3 ;
10235 int res3 = 0 ;
10236 unsigned char temp4 ;
10237 int res4 = 0 ;
10238 PyObject * obj0 = 0 ;
10239 PyObject * obj1 = 0 ;
10240 PyObject * obj2 = 0 ;
10241 PyObject * obj3 = 0 ;
10242 char *kwnames[] = {
10243 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10244 };
10245
10246 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10247 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10248 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10251 if (SWIG_arg_fail(1)) SWIG_fail;
10252 if (obj1) {
10253 {
10254 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10255 if (SWIG_arg_fail(5)) SWIG_fail;
10256 }
10257 }
10258 if (obj2) {
10259 {
10260 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10261 if (SWIG_arg_fail(6)) SWIG_fail;
10262 }
10263 }
10264 if (obj3) {
10265 {
10266 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10267 if (SWIG_arg_fail(7)) SWIG_fail;
10268 }
10269 }
10270 {
10271 PyThreadState* __tstate = wxPyBeginAllowThreads();
10272 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10273
10274 wxPyEndAllowThreads(__tstate);
10275 if (PyErr_Occurred()) SWIG_fail;
10276 }
10277 {
10278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10279 }
10280 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10281 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10282 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10283 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10284 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10285 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10286 return resultobj;
10287 fail:
10288 return NULL;
10289 }
10290
10291
10292 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10293 PyObject *obj;
10294 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10295 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10296 Py_INCREF(obj);
10297 return Py_BuildValue((char *)"");
10298 }
10299 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10300 PyObject *resultobj;
10301 wxString *arg1 = 0 ;
10302 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10303 int arg3 = (int) -1 ;
10304 wxImage *result;
10305 bool temp1 = false ;
10306 PyObject * obj0 = 0 ;
10307 PyObject * obj1 = 0 ;
10308 PyObject * obj2 = 0 ;
10309 char *kwnames[] = {
10310 (char *) "name",(char *) "type",(char *) "index", NULL
10311 };
10312
10313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10314 {
10315 arg1 = wxString_in_helper(obj0);
10316 if (arg1 == NULL) SWIG_fail;
10317 temp1 = true;
10318 }
10319 if (obj1) {
10320 {
10321 arg2 = (long)(SWIG_As_long(obj1));
10322 if (SWIG_arg_fail(2)) SWIG_fail;
10323 }
10324 }
10325 if (obj2) {
10326 {
10327 arg3 = (int)(SWIG_As_int(obj2));
10328 if (SWIG_arg_fail(3)) SWIG_fail;
10329 }
10330 }
10331 {
10332 PyThreadState* __tstate = wxPyBeginAllowThreads();
10333 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10334
10335 wxPyEndAllowThreads(__tstate);
10336 if (PyErr_Occurred()) SWIG_fail;
10337 }
10338 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10339 {
10340 if (temp1)
10341 delete arg1;
10342 }
10343 return resultobj;
10344 fail:
10345 {
10346 if (temp1)
10347 delete arg1;
10348 }
10349 return NULL;
10350 }
10351
10352
10353 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10354 PyObject *resultobj;
10355 wxImage *arg1 = (wxImage *) 0 ;
10356 PyObject * obj0 = 0 ;
10357 char *kwnames[] = {
10358 (char *) "self", NULL
10359 };
10360
10361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10363 if (SWIG_arg_fail(1)) SWIG_fail;
10364 {
10365 PyThreadState* __tstate = wxPyBeginAllowThreads();
10366 delete arg1;
10367
10368 wxPyEndAllowThreads(__tstate);
10369 if (PyErr_Occurred()) SWIG_fail;
10370 }
10371 Py_INCREF(Py_None); resultobj = Py_None;
10372 return resultobj;
10373 fail:
10374 return NULL;
10375 }
10376
10377
10378 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10379 PyObject *resultobj;
10380 wxString *arg1 = 0 ;
10381 wxString *arg2 = 0 ;
10382 int arg3 = (int) -1 ;
10383 wxImage *result;
10384 bool temp1 = false ;
10385 bool temp2 = false ;
10386 PyObject * obj0 = 0 ;
10387 PyObject * obj1 = 0 ;
10388 PyObject * obj2 = 0 ;
10389 char *kwnames[] = {
10390 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10391 };
10392
10393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10394 {
10395 arg1 = wxString_in_helper(obj0);
10396 if (arg1 == NULL) SWIG_fail;
10397 temp1 = true;
10398 }
10399 {
10400 arg2 = wxString_in_helper(obj1);
10401 if (arg2 == NULL) SWIG_fail;
10402 temp2 = true;
10403 }
10404 if (obj2) {
10405 {
10406 arg3 = (int)(SWIG_As_int(obj2));
10407 if (SWIG_arg_fail(3)) SWIG_fail;
10408 }
10409 }
10410 {
10411 PyThreadState* __tstate = wxPyBeginAllowThreads();
10412 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10413
10414 wxPyEndAllowThreads(__tstate);
10415 if (PyErr_Occurred()) SWIG_fail;
10416 }
10417 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10418 {
10419 if (temp1)
10420 delete arg1;
10421 }
10422 {
10423 if (temp2)
10424 delete arg2;
10425 }
10426 return resultobj;
10427 fail:
10428 {
10429 if (temp1)
10430 delete arg1;
10431 }
10432 {
10433 if (temp2)
10434 delete arg2;
10435 }
10436 return NULL;
10437 }
10438
10439
10440 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10441 PyObject *resultobj;
10442 wxInputStream *arg1 = 0 ;
10443 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10444 int arg3 = (int) -1 ;
10445 wxImage *result;
10446 wxPyInputStream *temp1 ;
10447 bool created1 ;
10448 PyObject * obj0 = 0 ;
10449 PyObject * obj1 = 0 ;
10450 PyObject * obj2 = 0 ;
10451 char *kwnames[] = {
10452 (char *) "stream",(char *) "type",(char *) "index", NULL
10453 };
10454
10455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10456 {
10457 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10458 arg1 = temp1->m_wxis;
10459 created1 = false;
10460 } else {
10461 PyErr_Clear(); // clear the failure of the wxPyConvert above
10462 arg1 = wxPyCBInputStream_create(obj0, false);
10463 if (arg1 == NULL) {
10464 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10465 SWIG_fail;
10466 }
10467 created1 = true;
10468 }
10469 }
10470 if (obj1) {
10471 {
10472 arg2 = (long)(SWIG_As_long(obj1));
10473 if (SWIG_arg_fail(2)) SWIG_fail;
10474 }
10475 }
10476 if (obj2) {
10477 {
10478 arg3 = (int)(SWIG_As_int(obj2));
10479 if (SWIG_arg_fail(3)) SWIG_fail;
10480 }
10481 }
10482 {
10483 PyThreadState* __tstate = wxPyBeginAllowThreads();
10484 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10485
10486 wxPyEndAllowThreads(__tstate);
10487 if (PyErr_Occurred()) SWIG_fail;
10488 }
10489 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10490 {
10491 if (created1)
10492 delete arg1;
10493 }
10494 return resultobj;
10495 fail:
10496 {
10497 if (created1)
10498 delete arg1;
10499 }
10500 return NULL;
10501 }
10502
10503
10504 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10505 PyObject *resultobj;
10506 wxInputStream *arg1 = 0 ;
10507 wxString *arg2 = 0 ;
10508 int arg3 = (int) -1 ;
10509 wxImage *result;
10510 wxPyInputStream *temp1 ;
10511 bool created1 ;
10512 bool temp2 = false ;
10513 PyObject * obj0 = 0 ;
10514 PyObject * obj1 = 0 ;
10515 PyObject * obj2 = 0 ;
10516 char *kwnames[] = {
10517 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10518 };
10519
10520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10521 {
10522 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10523 arg1 = temp1->m_wxis;
10524 created1 = false;
10525 } else {
10526 PyErr_Clear(); // clear the failure of the wxPyConvert above
10527 arg1 = wxPyCBInputStream_create(obj0, false);
10528 if (arg1 == NULL) {
10529 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10530 SWIG_fail;
10531 }
10532 created1 = true;
10533 }
10534 }
10535 {
10536 arg2 = wxString_in_helper(obj1);
10537 if (arg2 == NULL) SWIG_fail;
10538 temp2 = true;
10539 }
10540 if (obj2) {
10541 {
10542 arg3 = (int)(SWIG_As_int(obj2));
10543 if (SWIG_arg_fail(3)) SWIG_fail;
10544 }
10545 }
10546 {
10547 PyThreadState* __tstate = wxPyBeginAllowThreads();
10548 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10549
10550 wxPyEndAllowThreads(__tstate);
10551 if (PyErr_Occurred()) SWIG_fail;
10552 }
10553 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10554 {
10555 if (created1)
10556 delete arg1;
10557 }
10558 {
10559 if (temp2)
10560 delete arg2;
10561 }
10562 return resultobj;
10563 fail:
10564 {
10565 if (created1)
10566 delete arg1;
10567 }
10568 {
10569 if (temp2)
10570 delete arg2;
10571 }
10572 return NULL;
10573 }
10574
10575
10576 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10577 PyObject *resultobj;
10578 int arg1 = (int) 0 ;
10579 int arg2 = (int) 0 ;
10580 bool arg3 = (bool) true ;
10581 wxImage *result;
10582 PyObject * obj0 = 0 ;
10583 PyObject * obj1 = 0 ;
10584 PyObject * obj2 = 0 ;
10585 char *kwnames[] = {
10586 (char *) "width",(char *) "height",(char *) "clear", NULL
10587 };
10588
10589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10590 if (obj0) {
10591 {
10592 arg1 = (int)(SWIG_As_int(obj0));
10593 if (SWIG_arg_fail(1)) SWIG_fail;
10594 }
10595 }
10596 if (obj1) {
10597 {
10598 arg2 = (int)(SWIG_As_int(obj1));
10599 if (SWIG_arg_fail(2)) SWIG_fail;
10600 }
10601 }
10602 if (obj2) {
10603 {
10604 arg3 = (bool)(SWIG_As_bool(obj2));
10605 if (SWIG_arg_fail(3)) SWIG_fail;
10606 }
10607 }
10608 {
10609 PyThreadState* __tstate = wxPyBeginAllowThreads();
10610 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10611
10612 wxPyEndAllowThreads(__tstate);
10613 if (PyErr_Occurred()) SWIG_fail;
10614 }
10615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10616 return resultobj;
10617 fail:
10618 return NULL;
10619 }
10620
10621
10622 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10623 PyObject *resultobj;
10624 wxBitmap *arg1 = 0 ;
10625 wxImage *result;
10626 PyObject * obj0 = 0 ;
10627 char *kwnames[] = {
10628 (char *) "bitmap", NULL
10629 };
10630
10631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10632 {
10633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10634 if (SWIG_arg_fail(1)) SWIG_fail;
10635 if (arg1 == NULL) {
10636 SWIG_null_ref("wxBitmap");
10637 }
10638 if (SWIG_arg_fail(1)) SWIG_fail;
10639 }
10640 {
10641 if (!wxPyCheckForApp()) SWIG_fail;
10642 PyThreadState* __tstate = wxPyBeginAllowThreads();
10643 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10644
10645 wxPyEndAllowThreads(__tstate);
10646 if (PyErr_Occurred()) SWIG_fail;
10647 }
10648 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10649 return resultobj;
10650 fail:
10651 return NULL;
10652 }
10653
10654
10655 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10656 PyObject *resultobj;
10657 int arg1 ;
10658 int arg2 ;
10659 unsigned char *arg3 = (unsigned char *) 0 ;
10660 wxImage *result;
10661 PyObject * obj0 = 0 ;
10662 PyObject * obj1 = 0 ;
10663 PyObject * obj2 = 0 ;
10664 char *kwnames[] = {
10665 (char *) "width",(char *) "height",(char *) "data", NULL
10666 };
10667
10668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10669 {
10670 arg1 = (int)(SWIG_As_int(obj0));
10671 if (SWIG_arg_fail(1)) SWIG_fail;
10672 }
10673 {
10674 arg2 = (int)(SWIG_As_int(obj1));
10675 if (SWIG_arg_fail(2)) SWIG_fail;
10676 }
10677 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10678 if (SWIG_arg_fail(3)) SWIG_fail;
10679 {
10680 PyThreadState* __tstate = wxPyBeginAllowThreads();
10681 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10682
10683 wxPyEndAllowThreads(__tstate);
10684 if (PyErr_Occurred()) SWIG_fail;
10685 }
10686 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10687 return resultobj;
10688 fail:
10689 return NULL;
10690 }
10691
10692
10693 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10694 PyObject *resultobj;
10695 int arg1 ;
10696 int arg2 ;
10697 unsigned char *arg3 = (unsigned char *) 0 ;
10698 unsigned char *arg4 = (unsigned char *) 0 ;
10699 wxImage *result;
10700 PyObject * obj0 = 0 ;
10701 PyObject * obj1 = 0 ;
10702 PyObject * obj2 = 0 ;
10703 PyObject * obj3 = 0 ;
10704 char *kwnames[] = {
10705 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10706 };
10707
10708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10709 {
10710 arg1 = (int)(SWIG_As_int(obj0));
10711 if (SWIG_arg_fail(1)) SWIG_fail;
10712 }
10713 {
10714 arg2 = (int)(SWIG_As_int(obj1));
10715 if (SWIG_arg_fail(2)) SWIG_fail;
10716 }
10717 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10718 if (SWIG_arg_fail(3)) SWIG_fail;
10719 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10720 if (SWIG_arg_fail(4)) SWIG_fail;
10721 {
10722 PyThreadState* __tstate = wxPyBeginAllowThreads();
10723 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10724
10725 wxPyEndAllowThreads(__tstate);
10726 if (PyErr_Occurred()) SWIG_fail;
10727 }
10728 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10729 return resultobj;
10730 fail:
10731 return NULL;
10732 }
10733
10734
10735 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10736 PyObject *resultobj;
10737 wxImage *arg1 = (wxImage *) 0 ;
10738 int arg2 ;
10739 int arg3 ;
10740 PyObject * obj0 = 0 ;
10741 PyObject * obj1 = 0 ;
10742 PyObject * obj2 = 0 ;
10743 char *kwnames[] = {
10744 (char *) "self",(char *) "width",(char *) "height", NULL
10745 };
10746
10747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10749 if (SWIG_arg_fail(1)) SWIG_fail;
10750 {
10751 arg2 = (int)(SWIG_As_int(obj1));
10752 if (SWIG_arg_fail(2)) SWIG_fail;
10753 }
10754 {
10755 arg3 = (int)(SWIG_As_int(obj2));
10756 if (SWIG_arg_fail(3)) SWIG_fail;
10757 }
10758 {
10759 PyThreadState* __tstate = wxPyBeginAllowThreads();
10760 (arg1)->Create(arg2,arg3);
10761
10762 wxPyEndAllowThreads(__tstate);
10763 if (PyErr_Occurred()) SWIG_fail;
10764 }
10765 Py_INCREF(Py_None); resultobj = Py_None;
10766 return resultobj;
10767 fail:
10768 return NULL;
10769 }
10770
10771
10772 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10773 PyObject *resultobj;
10774 wxImage *arg1 = (wxImage *) 0 ;
10775 PyObject * obj0 = 0 ;
10776 char *kwnames[] = {
10777 (char *) "self", NULL
10778 };
10779
10780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10782 if (SWIG_arg_fail(1)) SWIG_fail;
10783 {
10784 PyThreadState* __tstate = wxPyBeginAllowThreads();
10785 (arg1)->Destroy();
10786
10787 wxPyEndAllowThreads(__tstate);
10788 if (PyErr_Occurred()) SWIG_fail;
10789 }
10790 Py_INCREF(Py_None); resultobj = Py_None;
10791 return resultobj;
10792 fail:
10793 return NULL;
10794 }
10795
10796
10797 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10798 PyObject *resultobj;
10799 wxImage *arg1 = (wxImage *) 0 ;
10800 int arg2 ;
10801 int arg3 ;
10802 SwigValueWrapper<wxImage > result;
10803 PyObject * obj0 = 0 ;
10804 PyObject * obj1 = 0 ;
10805 PyObject * obj2 = 0 ;
10806 char *kwnames[] = {
10807 (char *) "self",(char *) "width",(char *) "height", NULL
10808 };
10809
10810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10812 if (SWIG_arg_fail(1)) SWIG_fail;
10813 {
10814 arg2 = (int)(SWIG_As_int(obj1));
10815 if (SWIG_arg_fail(2)) SWIG_fail;
10816 }
10817 {
10818 arg3 = (int)(SWIG_As_int(obj2));
10819 if (SWIG_arg_fail(3)) SWIG_fail;
10820 }
10821 {
10822 PyThreadState* __tstate = wxPyBeginAllowThreads();
10823 result = (arg1)->Scale(arg2,arg3);
10824
10825 wxPyEndAllowThreads(__tstate);
10826 if (PyErr_Occurred()) SWIG_fail;
10827 }
10828 {
10829 wxImage * resultptr;
10830 resultptr = new wxImage((wxImage &)(result));
10831 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10832 }
10833 return resultobj;
10834 fail:
10835 return NULL;
10836 }
10837
10838
10839 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10840 PyObject *resultobj;
10841 wxImage *arg1 = (wxImage *) 0 ;
10842 int arg2 ;
10843 int arg3 ;
10844 SwigValueWrapper<wxImage > result;
10845 PyObject * obj0 = 0 ;
10846 PyObject * obj1 = 0 ;
10847 PyObject * obj2 = 0 ;
10848 char *kwnames[] = {
10849 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10850 };
10851
10852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10854 if (SWIG_arg_fail(1)) SWIG_fail;
10855 {
10856 arg2 = (int)(SWIG_As_int(obj1));
10857 if (SWIG_arg_fail(2)) SWIG_fail;
10858 }
10859 {
10860 arg3 = (int)(SWIG_As_int(obj2));
10861 if (SWIG_arg_fail(3)) SWIG_fail;
10862 }
10863 {
10864 PyThreadState* __tstate = wxPyBeginAllowThreads();
10865 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10866
10867 wxPyEndAllowThreads(__tstate);
10868 if (PyErr_Occurred()) SWIG_fail;
10869 }
10870 {
10871 wxImage * resultptr;
10872 resultptr = new wxImage((wxImage &)(result));
10873 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10874 }
10875 return resultobj;
10876 fail:
10877 return NULL;
10878 }
10879
10880
10881 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10882 PyObject *resultobj;
10883 wxImage *arg1 = (wxImage *) 0 ;
10884 int arg2 ;
10885 int arg3 ;
10886 wxImage *result;
10887 PyObject * obj0 = 0 ;
10888 PyObject * obj1 = 0 ;
10889 PyObject * obj2 = 0 ;
10890 char *kwnames[] = {
10891 (char *) "self",(char *) "width",(char *) "height", NULL
10892 };
10893
10894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10896 if (SWIG_arg_fail(1)) SWIG_fail;
10897 {
10898 arg2 = (int)(SWIG_As_int(obj1));
10899 if (SWIG_arg_fail(2)) SWIG_fail;
10900 }
10901 {
10902 arg3 = (int)(SWIG_As_int(obj2));
10903 if (SWIG_arg_fail(3)) SWIG_fail;
10904 }
10905 {
10906 PyThreadState* __tstate = wxPyBeginAllowThreads();
10907 {
10908 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10909 result = (wxImage *) &_result_ref;
10910 }
10911
10912 wxPyEndAllowThreads(__tstate);
10913 if (PyErr_Occurred()) SWIG_fail;
10914 }
10915 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10916 return resultobj;
10917 fail:
10918 return NULL;
10919 }
10920
10921
10922 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10923 PyObject *resultobj;
10924 wxImage *arg1 = (wxImage *) 0 ;
10925 int arg2 ;
10926 int arg3 ;
10927 unsigned char arg4 ;
10928 unsigned char arg5 ;
10929 unsigned char arg6 ;
10930 PyObject * obj0 = 0 ;
10931 PyObject * obj1 = 0 ;
10932 PyObject * obj2 = 0 ;
10933 PyObject * obj3 = 0 ;
10934 PyObject * obj4 = 0 ;
10935 PyObject * obj5 = 0 ;
10936 char *kwnames[] = {
10937 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
10938 };
10939
10940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10942 if (SWIG_arg_fail(1)) SWIG_fail;
10943 {
10944 arg2 = (int)(SWIG_As_int(obj1));
10945 if (SWIG_arg_fail(2)) SWIG_fail;
10946 }
10947 {
10948 arg3 = (int)(SWIG_As_int(obj2));
10949 if (SWIG_arg_fail(3)) SWIG_fail;
10950 }
10951 {
10952 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10953 if (SWIG_arg_fail(4)) SWIG_fail;
10954 }
10955 {
10956 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
10957 if (SWIG_arg_fail(5)) SWIG_fail;
10958 }
10959 {
10960 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
10961 if (SWIG_arg_fail(6)) SWIG_fail;
10962 }
10963 {
10964 PyThreadState* __tstate = wxPyBeginAllowThreads();
10965 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
10966
10967 wxPyEndAllowThreads(__tstate);
10968 if (PyErr_Occurred()) SWIG_fail;
10969 }
10970 Py_INCREF(Py_None); resultobj = Py_None;
10971 return resultobj;
10972 fail:
10973 return NULL;
10974 }
10975
10976
10977 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
10978 PyObject *resultobj;
10979 wxImage *arg1 = (wxImage *) 0 ;
10980 int arg2 ;
10981 int arg3 ;
10982 unsigned char result;
10983 PyObject * obj0 = 0 ;
10984 PyObject * obj1 = 0 ;
10985 PyObject * obj2 = 0 ;
10986 char *kwnames[] = {
10987 (char *) "self",(char *) "x",(char *) "y", NULL
10988 };
10989
10990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
10991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10992 if (SWIG_arg_fail(1)) SWIG_fail;
10993 {
10994 arg2 = (int)(SWIG_As_int(obj1));
10995 if (SWIG_arg_fail(2)) SWIG_fail;
10996 }
10997 {
10998 arg3 = (int)(SWIG_As_int(obj2));
10999 if (SWIG_arg_fail(3)) SWIG_fail;
11000 }
11001 {
11002 PyThreadState* __tstate = wxPyBeginAllowThreads();
11003 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11004
11005 wxPyEndAllowThreads(__tstate);
11006 if (PyErr_Occurred()) SWIG_fail;
11007 }
11008 {
11009 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11010 }
11011 return resultobj;
11012 fail:
11013 return NULL;
11014 }
11015
11016
11017 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11018 PyObject *resultobj;
11019 wxImage *arg1 = (wxImage *) 0 ;
11020 int arg2 ;
11021 int arg3 ;
11022 unsigned char result;
11023 PyObject * obj0 = 0 ;
11024 PyObject * obj1 = 0 ;
11025 PyObject * obj2 = 0 ;
11026 char *kwnames[] = {
11027 (char *) "self",(char *) "x",(char *) "y", NULL
11028 };
11029
11030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11032 if (SWIG_arg_fail(1)) SWIG_fail;
11033 {
11034 arg2 = (int)(SWIG_As_int(obj1));
11035 if (SWIG_arg_fail(2)) SWIG_fail;
11036 }
11037 {
11038 arg3 = (int)(SWIG_As_int(obj2));
11039 if (SWIG_arg_fail(3)) SWIG_fail;
11040 }
11041 {
11042 PyThreadState* __tstate = wxPyBeginAllowThreads();
11043 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11044
11045 wxPyEndAllowThreads(__tstate);
11046 if (PyErr_Occurred()) SWIG_fail;
11047 }
11048 {
11049 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11050 }
11051 return resultobj;
11052 fail:
11053 return NULL;
11054 }
11055
11056
11057 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11058 PyObject *resultobj;
11059 wxImage *arg1 = (wxImage *) 0 ;
11060 int arg2 ;
11061 int arg3 ;
11062 unsigned char result;
11063 PyObject * obj0 = 0 ;
11064 PyObject * obj1 = 0 ;
11065 PyObject * obj2 = 0 ;
11066 char *kwnames[] = {
11067 (char *) "self",(char *) "x",(char *) "y", NULL
11068 };
11069
11070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11072 if (SWIG_arg_fail(1)) SWIG_fail;
11073 {
11074 arg2 = (int)(SWIG_As_int(obj1));
11075 if (SWIG_arg_fail(2)) SWIG_fail;
11076 }
11077 {
11078 arg3 = (int)(SWIG_As_int(obj2));
11079 if (SWIG_arg_fail(3)) SWIG_fail;
11080 }
11081 {
11082 PyThreadState* __tstate = wxPyBeginAllowThreads();
11083 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11084
11085 wxPyEndAllowThreads(__tstate);
11086 if (PyErr_Occurred()) SWIG_fail;
11087 }
11088 {
11089 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11090 }
11091 return resultobj;
11092 fail:
11093 return NULL;
11094 }
11095
11096
11097 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11098 PyObject *resultobj;
11099 wxImage *arg1 = (wxImage *) 0 ;
11100 int arg2 ;
11101 int arg3 ;
11102 unsigned char arg4 ;
11103 PyObject * obj0 = 0 ;
11104 PyObject * obj1 = 0 ;
11105 PyObject * obj2 = 0 ;
11106 PyObject * obj3 = 0 ;
11107 char *kwnames[] = {
11108 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11109 };
11110
11111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11113 if (SWIG_arg_fail(1)) SWIG_fail;
11114 {
11115 arg2 = (int)(SWIG_As_int(obj1));
11116 if (SWIG_arg_fail(2)) SWIG_fail;
11117 }
11118 {
11119 arg3 = (int)(SWIG_As_int(obj2));
11120 if (SWIG_arg_fail(3)) SWIG_fail;
11121 }
11122 {
11123 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11124 if (SWIG_arg_fail(4)) SWIG_fail;
11125 }
11126 {
11127 PyThreadState* __tstate = wxPyBeginAllowThreads();
11128 (arg1)->SetAlpha(arg2,arg3,arg4);
11129
11130 wxPyEndAllowThreads(__tstate);
11131 if (PyErr_Occurred()) SWIG_fail;
11132 }
11133 Py_INCREF(Py_None); resultobj = Py_None;
11134 return resultobj;
11135 fail:
11136 return NULL;
11137 }
11138
11139
11140 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11141 PyObject *resultobj;
11142 wxImage *arg1 = (wxImage *) 0 ;
11143 int arg2 ;
11144 int arg3 ;
11145 unsigned char result;
11146 PyObject * obj0 = 0 ;
11147 PyObject * obj1 = 0 ;
11148 PyObject * obj2 = 0 ;
11149 char *kwnames[] = {
11150 (char *) "self",(char *) "x",(char *) "y", NULL
11151 };
11152
11153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11155 if (SWIG_arg_fail(1)) SWIG_fail;
11156 {
11157 arg2 = (int)(SWIG_As_int(obj1));
11158 if (SWIG_arg_fail(2)) SWIG_fail;
11159 }
11160 {
11161 arg3 = (int)(SWIG_As_int(obj2));
11162 if (SWIG_arg_fail(3)) SWIG_fail;
11163 }
11164 {
11165 PyThreadState* __tstate = wxPyBeginAllowThreads();
11166 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11167
11168 wxPyEndAllowThreads(__tstate);
11169 if (PyErr_Occurred()) SWIG_fail;
11170 }
11171 {
11172 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11173 }
11174 return resultobj;
11175 fail:
11176 return NULL;
11177 }
11178
11179
11180 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11181 PyObject *resultobj;
11182 wxImage *arg1 = (wxImage *) 0 ;
11183 bool result;
11184 PyObject * obj0 = 0 ;
11185 char *kwnames[] = {
11186 (char *) "self", NULL
11187 };
11188
11189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11191 if (SWIG_arg_fail(1)) SWIG_fail;
11192 {
11193 PyThreadState* __tstate = wxPyBeginAllowThreads();
11194 result = (bool)(arg1)->HasAlpha();
11195
11196 wxPyEndAllowThreads(__tstate);
11197 if (PyErr_Occurred()) SWIG_fail;
11198 }
11199 {
11200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11201 }
11202 return resultobj;
11203 fail:
11204 return NULL;
11205 }
11206
11207
11208 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11209 PyObject *resultobj;
11210 wxImage *arg1 = (wxImage *) 0 ;
11211 byte *arg2 = (byte *) 0 ;
11212 byte *arg3 = (byte *) 0 ;
11213 byte *arg4 = (byte *) 0 ;
11214 byte arg5 = (byte) 0 ;
11215 byte arg6 = (byte) 0 ;
11216 byte arg7 = (byte) 0 ;
11217 bool result;
11218 byte temp2 ;
11219 int res2 = 0 ;
11220 byte temp3 ;
11221 int res3 = 0 ;
11222 byte temp4 ;
11223 int res4 = 0 ;
11224 PyObject * obj0 = 0 ;
11225 PyObject * obj1 = 0 ;
11226 PyObject * obj2 = 0 ;
11227 PyObject * obj3 = 0 ;
11228 char *kwnames[] = {
11229 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11230 };
11231
11232 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11233 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11234 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11237 if (SWIG_arg_fail(1)) SWIG_fail;
11238 if (obj1) {
11239 {
11240 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11241 if (SWIG_arg_fail(5)) SWIG_fail;
11242 }
11243 }
11244 if (obj2) {
11245 {
11246 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11247 if (SWIG_arg_fail(6)) SWIG_fail;
11248 }
11249 }
11250 if (obj3) {
11251 {
11252 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11253 if (SWIG_arg_fail(7)) SWIG_fail;
11254 }
11255 }
11256 {
11257 PyThreadState* __tstate = wxPyBeginAllowThreads();
11258 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11259
11260 wxPyEndAllowThreads(__tstate);
11261 if (PyErr_Occurred()) SWIG_fail;
11262 }
11263 {
11264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11265 }
11266 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11267 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11268 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11269 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11270 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11271 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11272 return resultobj;
11273 fail:
11274 return NULL;
11275 }
11276
11277
11278 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11279 PyObject *resultobj;
11280 wxImage *arg1 = (wxImage *) 0 ;
11281 byte arg2 = (byte) 128 ;
11282 bool result;
11283 PyObject * obj0 = 0 ;
11284 PyObject * obj1 = 0 ;
11285 char *kwnames[] = {
11286 (char *) "self",(char *) "threshold", NULL
11287 };
11288
11289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11291 if (SWIG_arg_fail(1)) SWIG_fail;
11292 if (obj1) {
11293 {
11294 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11295 if (SWIG_arg_fail(2)) SWIG_fail;
11296 }
11297 }
11298 {
11299 PyThreadState* __tstate = wxPyBeginAllowThreads();
11300 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11301
11302 wxPyEndAllowThreads(__tstate);
11303 if (PyErr_Occurred()) SWIG_fail;
11304 }
11305 {
11306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11307 }
11308 return resultobj;
11309 fail:
11310 return NULL;
11311 }
11312
11313
11314 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11315 PyObject *resultobj;
11316 wxImage *arg1 = (wxImage *) 0 ;
11317 unsigned char arg2 ;
11318 unsigned char arg3 ;
11319 unsigned char arg4 ;
11320 bool result;
11321 PyObject * obj0 = 0 ;
11322 PyObject * obj1 = 0 ;
11323 PyObject * obj2 = 0 ;
11324 PyObject * obj3 = 0 ;
11325 char *kwnames[] = {
11326 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11327 };
11328
11329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11331 if (SWIG_arg_fail(1)) SWIG_fail;
11332 {
11333 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11334 if (SWIG_arg_fail(2)) SWIG_fail;
11335 }
11336 {
11337 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11338 if (SWIG_arg_fail(3)) SWIG_fail;
11339 }
11340 {
11341 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11342 if (SWIG_arg_fail(4)) SWIG_fail;
11343 }
11344 {
11345 PyThreadState* __tstate = wxPyBeginAllowThreads();
11346 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11347
11348 wxPyEndAllowThreads(__tstate);
11349 if (PyErr_Occurred()) SWIG_fail;
11350 }
11351 {
11352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11353 }
11354 return resultobj;
11355 fail:
11356 return NULL;
11357 }
11358
11359
11360 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11361 PyObject *resultobj;
11362 wxImage *arg1 = (wxImage *) 0 ;
11363 wxImage *arg2 = 0 ;
11364 byte arg3 ;
11365 byte arg4 ;
11366 byte arg5 ;
11367 bool result;
11368 PyObject * obj0 = 0 ;
11369 PyObject * obj1 = 0 ;
11370 PyObject * obj2 = 0 ;
11371 PyObject * obj3 = 0 ;
11372 PyObject * obj4 = 0 ;
11373 char *kwnames[] = {
11374 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11375 };
11376
11377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11379 if (SWIG_arg_fail(1)) SWIG_fail;
11380 {
11381 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11382 if (SWIG_arg_fail(2)) SWIG_fail;
11383 if (arg2 == NULL) {
11384 SWIG_null_ref("wxImage");
11385 }
11386 if (SWIG_arg_fail(2)) SWIG_fail;
11387 }
11388 {
11389 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11390 if (SWIG_arg_fail(3)) SWIG_fail;
11391 }
11392 {
11393 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11394 if (SWIG_arg_fail(4)) SWIG_fail;
11395 }
11396 {
11397 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11398 if (SWIG_arg_fail(5)) SWIG_fail;
11399 }
11400 {
11401 PyThreadState* __tstate = wxPyBeginAllowThreads();
11402 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11403
11404 wxPyEndAllowThreads(__tstate);
11405 if (PyErr_Occurred()) SWIG_fail;
11406 }
11407 {
11408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11409 }
11410 return resultobj;
11411 fail:
11412 return NULL;
11413 }
11414
11415
11416 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11417 PyObject *resultobj;
11418 wxString *arg1 = 0 ;
11419 bool result;
11420 bool temp1 = false ;
11421 PyObject * obj0 = 0 ;
11422 char *kwnames[] = {
11423 (char *) "name", NULL
11424 };
11425
11426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11427 {
11428 arg1 = wxString_in_helper(obj0);
11429 if (arg1 == NULL) SWIG_fail;
11430 temp1 = true;
11431 }
11432 {
11433 PyThreadState* __tstate = wxPyBeginAllowThreads();
11434 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11435
11436 wxPyEndAllowThreads(__tstate);
11437 if (PyErr_Occurred()) SWIG_fail;
11438 }
11439 {
11440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11441 }
11442 {
11443 if (temp1)
11444 delete arg1;
11445 }
11446 return resultobj;
11447 fail:
11448 {
11449 if (temp1)
11450 delete arg1;
11451 }
11452 return NULL;
11453 }
11454
11455
11456 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11457 PyObject *resultobj;
11458 wxString *arg1 = 0 ;
11459 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11460 int result;
11461 bool temp1 = false ;
11462 PyObject * obj0 = 0 ;
11463 PyObject * obj1 = 0 ;
11464 char *kwnames[] = {
11465 (char *) "name",(char *) "type", NULL
11466 };
11467
11468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11469 {
11470 arg1 = wxString_in_helper(obj0);
11471 if (arg1 == NULL) SWIG_fail;
11472 temp1 = true;
11473 }
11474 if (obj1) {
11475 {
11476 arg2 = (long)(SWIG_As_long(obj1));
11477 if (SWIG_arg_fail(2)) SWIG_fail;
11478 }
11479 }
11480 {
11481 PyThreadState* __tstate = wxPyBeginAllowThreads();
11482 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11483
11484 wxPyEndAllowThreads(__tstate);
11485 if (PyErr_Occurred()) SWIG_fail;
11486 }
11487 {
11488 resultobj = SWIG_From_int((int)(result));
11489 }
11490 {
11491 if (temp1)
11492 delete arg1;
11493 }
11494 return resultobj;
11495 fail:
11496 {
11497 if (temp1)
11498 delete arg1;
11499 }
11500 return NULL;
11501 }
11502
11503
11504 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11505 PyObject *resultobj;
11506 wxImage *arg1 = (wxImage *) 0 ;
11507 wxString *arg2 = 0 ;
11508 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11509 int arg4 = (int) -1 ;
11510 bool result;
11511 bool temp2 = false ;
11512 PyObject * obj0 = 0 ;
11513 PyObject * obj1 = 0 ;
11514 PyObject * obj2 = 0 ;
11515 PyObject * obj3 = 0 ;
11516 char *kwnames[] = {
11517 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11518 };
11519
11520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11522 if (SWIG_arg_fail(1)) SWIG_fail;
11523 {
11524 arg2 = wxString_in_helper(obj1);
11525 if (arg2 == NULL) SWIG_fail;
11526 temp2 = true;
11527 }
11528 if (obj2) {
11529 {
11530 arg3 = (long)(SWIG_As_long(obj2));
11531 if (SWIG_arg_fail(3)) SWIG_fail;
11532 }
11533 }
11534 if (obj3) {
11535 {
11536 arg4 = (int)(SWIG_As_int(obj3));
11537 if (SWIG_arg_fail(4)) SWIG_fail;
11538 }
11539 }
11540 {
11541 PyThreadState* __tstate = wxPyBeginAllowThreads();
11542 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11543
11544 wxPyEndAllowThreads(__tstate);
11545 if (PyErr_Occurred()) SWIG_fail;
11546 }
11547 {
11548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11549 }
11550 {
11551 if (temp2)
11552 delete arg2;
11553 }
11554 return resultobj;
11555 fail:
11556 {
11557 if (temp2)
11558 delete arg2;
11559 }
11560 return NULL;
11561 }
11562
11563
11564 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11565 PyObject *resultobj;
11566 wxImage *arg1 = (wxImage *) 0 ;
11567 wxString *arg2 = 0 ;
11568 wxString *arg3 = 0 ;
11569 int arg4 = (int) -1 ;
11570 bool result;
11571 bool temp2 = false ;
11572 bool temp3 = false ;
11573 PyObject * obj0 = 0 ;
11574 PyObject * obj1 = 0 ;
11575 PyObject * obj2 = 0 ;
11576 PyObject * obj3 = 0 ;
11577 char *kwnames[] = {
11578 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11579 };
11580
11581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11583 if (SWIG_arg_fail(1)) SWIG_fail;
11584 {
11585 arg2 = wxString_in_helper(obj1);
11586 if (arg2 == NULL) SWIG_fail;
11587 temp2 = true;
11588 }
11589 {
11590 arg3 = wxString_in_helper(obj2);
11591 if (arg3 == NULL) SWIG_fail;
11592 temp3 = true;
11593 }
11594 if (obj3) {
11595 {
11596 arg4 = (int)(SWIG_As_int(obj3));
11597 if (SWIG_arg_fail(4)) SWIG_fail;
11598 }
11599 }
11600 {
11601 PyThreadState* __tstate = wxPyBeginAllowThreads();
11602 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11603
11604 wxPyEndAllowThreads(__tstate);
11605 if (PyErr_Occurred()) SWIG_fail;
11606 }
11607 {
11608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11609 }
11610 {
11611 if (temp2)
11612 delete arg2;
11613 }
11614 {
11615 if (temp3)
11616 delete arg3;
11617 }
11618 return resultobj;
11619 fail:
11620 {
11621 if (temp2)
11622 delete arg2;
11623 }
11624 {
11625 if (temp3)
11626 delete arg3;
11627 }
11628 return NULL;
11629 }
11630
11631
11632 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11633 PyObject *resultobj;
11634 wxImage *arg1 = (wxImage *) 0 ;
11635 wxString *arg2 = 0 ;
11636 int arg3 ;
11637 bool result;
11638 bool temp2 = false ;
11639 PyObject * obj0 = 0 ;
11640 PyObject * obj1 = 0 ;
11641 PyObject * obj2 = 0 ;
11642 char *kwnames[] = {
11643 (char *) "self",(char *) "name",(char *) "type", NULL
11644 };
11645
11646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11648 if (SWIG_arg_fail(1)) SWIG_fail;
11649 {
11650 arg2 = wxString_in_helper(obj1);
11651 if (arg2 == NULL) SWIG_fail;
11652 temp2 = true;
11653 }
11654 {
11655 arg3 = (int)(SWIG_As_int(obj2));
11656 if (SWIG_arg_fail(3)) SWIG_fail;
11657 }
11658 {
11659 PyThreadState* __tstate = wxPyBeginAllowThreads();
11660 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11661
11662 wxPyEndAllowThreads(__tstate);
11663 if (PyErr_Occurred()) SWIG_fail;
11664 }
11665 {
11666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11667 }
11668 {
11669 if (temp2)
11670 delete arg2;
11671 }
11672 return resultobj;
11673 fail:
11674 {
11675 if (temp2)
11676 delete arg2;
11677 }
11678 return NULL;
11679 }
11680
11681
11682 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11683 PyObject *resultobj;
11684 wxImage *arg1 = (wxImage *) 0 ;
11685 wxString *arg2 = 0 ;
11686 wxString *arg3 = 0 ;
11687 bool result;
11688 bool temp2 = false ;
11689 bool temp3 = false ;
11690 PyObject * obj0 = 0 ;
11691 PyObject * obj1 = 0 ;
11692 PyObject * obj2 = 0 ;
11693 char *kwnames[] = {
11694 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11695 };
11696
11697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11699 if (SWIG_arg_fail(1)) SWIG_fail;
11700 {
11701 arg2 = wxString_in_helper(obj1);
11702 if (arg2 == NULL) SWIG_fail;
11703 temp2 = true;
11704 }
11705 {
11706 arg3 = wxString_in_helper(obj2);
11707 if (arg3 == NULL) SWIG_fail;
11708 temp3 = true;
11709 }
11710 {
11711 PyThreadState* __tstate = wxPyBeginAllowThreads();
11712 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11713
11714 wxPyEndAllowThreads(__tstate);
11715 if (PyErr_Occurred()) SWIG_fail;
11716 }
11717 {
11718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11719 }
11720 {
11721 if (temp2)
11722 delete arg2;
11723 }
11724 {
11725 if (temp3)
11726 delete arg3;
11727 }
11728 return resultobj;
11729 fail:
11730 {
11731 if (temp2)
11732 delete arg2;
11733 }
11734 {
11735 if (temp3)
11736 delete arg3;
11737 }
11738 return NULL;
11739 }
11740
11741
11742 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11743 PyObject *resultobj;
11744 wxInputStream *arg1 = 0 ;
11745 bool result;
11746 wxPyInputStream *temp1 ;
11747 bool created1 ;
11748 PyObject * obj0 = 0 ;
11749 char *kwnames[] = {
11750 (char *) "stream", NULL
11751 };
11752
11753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11754 {
11755 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11756 arg1 = temp1->m_wxis;
11757 created1 = false;
11758 } else {
11759 PyErr_Clear(); // clear the failure of the wxPyConvert above
11760 arg1 = wxPyCBInputStream_create(obj0, false);
11761 if (arg1 == NULL) {
11762 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11763 SWIG_fail;
11764 }
11765 created1 = true;
11766 }
11767 }
11768 {
11769 PyThreadState* __tstate = wxPyBeginAllowThreads();
11770 result = (bool)wxImage::CanRead(*arg1);
11771
11772 wxPyEndAllowThreads(__tstate);
11773 if (PyErr_Occurred()) SWIG_fail;
11774 }
11775 {
11776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11777 }
11778 {
11779 if (created1)
11780 delete arg1;
11781 }
11782 return resultobj;
11783 fail:
11784 {
11785 if (created1)
11786 delete arg1;
11787 }
11788 return NULL;
11789 }
11790
11791
11792 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11793 PyObject *resultobj;
11794 wxImage *arg1 = (wxImage *) 0 ;
11795 wxInputStream *arg2 = 0 ;
11796 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11797 int arg4 = (int) -1 ;
11798 bool result;
11799 wxPyInputStream *temp2 ;
11800 bool created2 ;
11801 PyObject * obj0 = 0 ;
11802 PyObject * obj1 = 0 ;
11803 PyObject * obj2 = 0 ;
11804 PyObject * obj3 = 0 ;
11805 char *kwnames[] = {
11806 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11807 };
11808
11809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11811 if (SWIG_arg_fail(1)) SWIG_fail;
11812 {
11813 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11814 arg2 = temp2->m_wxis;
11815 created2 = false;
11816 } else {
11817 PyErr_Clear(); // clear the failure of the wxPyConvert above
11818 arg2 = wxPyCBInputStream_create(obj1, false);
11819 if (arg2 == NULL) {
11820 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11821 SWIG_fail;
11822 }
11823 created2 = true;
11824 }
11825 }
11826 if (obj2) {
11827 {
11828 arg3 = (long)(SWIG_As_long(obj2));
11829 if (SWIG_arg_fail(3)) SWIG_fail;
11830 }
11831 }
11832 if (obj3) {
11833 {
11834 arg4 = (int)(SWIG_As_int(obj3));
11835 if (SWIG_arg_fail(4)) SWIG_fail;
11836 }
11837 }
11838 {
11839 PyThreadState* __tstate = wxPyBeginAllowThreads();
11840 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
11841
11842 wxPyEndAllowThreads(__tstate);
11843 if (PyErr_Occurred()) SWIG_fail;
11844 }
11845 {
11846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11847 }
11848 {
11849 if (created2)
11850 delete arg2;
11851 }
11852 return resultobj;
11853 fail:
11854 {
11855 if (created2)
11856 delete arg2;
11857 }
11858 return NULL;
11859 }
11860
11861
11862 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
11863 PyObject *resultobj;
11864 wxImage *arg1 = (wxImage *) 0 ;
11865 wxInputStream *arg2 = 0 ;
11866 wxString *arg3 = 0 ;
11867 int arg4 = (int) -1 ;
11868 bool result;
11869 wxPyInputStream *temp2 ;
11870 bool created2 ;
11871 bool temp3 = false ;
11872 PyObject * obj0 = 0 ;
11873 PyObject * obj1 = 0 ;
11874 PyObject * obj2 = 0 ;
11875 PyObject * obj3 = 0 ;
11876 char *kwnames[] = {
11877 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
11878 };
11879
11880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11882 if (SWIG_arg_fail(1)) SWIG_fail;
11883 {
11884 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11885 arg2 = temp2->m_wxis;
11886 created2 = false;
11887 } else {
11888 PyErr_Clear(); // clear the failure of the wxPyConvert above
11889 arg2 = wxPyCBInputStream_create(obj1, false);
11890 if (arg2 == NULL) {
11891 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11892 SWIG_fail;
11893 }
11894 created2 = true;
11895 }
11896 }
11897 {
11898 arg3 = wxString_in_helper(obj2);
11899 if (arg3 == NULL) SWIG_fail;
11900 temp3 = true;
11901 }
11902 if (obj3) {
11903 {
11904 arg4 = (int)(SWIG_As_int(obj3));
11905 if (SWIG_arg_fail(4)) SWIG_fail;
11906 }
11907 }
11908 {
11909 PyThreadState* __tstate = wxPyBeginAllowThreads();
11910 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
11911
11912 wxPyEndAllowThreads(__tstate);
11913 if (PyErr_Occurred()) SWIG_fail;
11914 }
11915 {
11916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11917 }
11918 {
11919 if (created2)
11920 delete arg2;
11921 }
11922 {
11923 if (temp3)
11924 delete arg3;
11925 }
11926 return resultobj;
11927 fail:
11928 {
11929 if (created2)
11930 delete arg2;
11931 }
11932 {
11933 if (temp3)
11934 delete arg3;
11935 }
11936 return NULL;
11937 }
11938
11939
11940 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
11941 PyObject *resultobj;
11942 wxImage *arg1 = (wxImage *) 0 ;
11943 bool result;
11944 PyObject * obj0 = 0 ;
11945 char *kwnames[] = {
11946 (char *) "self", NULL
11947 };
11948
11949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
11950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11951 if (SWIG_arg_fail(1)) SWIG_fail;
11952 {
11953 PyThreadState* __tstate = wxPyBeginAllowThreads();
11954 result = (bool)(arg1)->Ok();
11955
11956 wxPyEndAllowThreads(__tstate);
11957 if (PyErr_Occurred()) SWIG_fail;
11958 }
11959 {
11960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11961 }
11962 return resultobj;
11963 fail:
11964 return NULL;
11965 }
11966
11967
11968 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
11969 PyObject *resultobj;
11970 wxImage *arg1 = (wxImage *) 0 ;
11971 int result;
11972 PyObject * obj0 = 0 ;
11973 char *kwnames[] = {
11974 (char *) "self", NULL
11975 };
11976
11977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
11978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11979 if (SWIG_arg_fail(1)) SWIG_fail;
11980 {
11981 PyThreadState* __tstate = wxPyBeginAllowThreads();
11982 result = (int)(arg1)->GetWidth();
11983
11984 wxPyEndAllowThreads(__tstate);
11985 if (PyErr_Occurred()) SWIG_fail;
11986 }
11987 {
11988 resultobj = SWIG_From_int((int)(result));
11989 }
11990 return resultobj;
11991 fail:
11992 return NULL;
11993 }
11994
11995
11996 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
11997 PyObject *resultobj;
11998 wxImage *arg1 = (wxImage *) 0 ;
11999 int result;
12000 PyObject * obj0 = 0 ;
12001 char *kwnames[] = {
12002 (char *) "self", NULL
12003 };
12004
12005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12007 if (SWIG_arg_fail(1)) SWIG_fail;
12008 {
12009 PyThreadState* __tstate = wxPyBeginAllowThreads();
12010 result = (int)(arg1)->GetHeight();
12011
12012 wxPyEndAllowThreads(__tstate);
12013 if (PyErr_Occurred()) SWIG_fail;
12014 }
12015 {
12016 resultobj = SWIG_From_int((int)(result));
12017 }
12018 return resultobj;
12019 fail:
12020 return NULL;
12021 }
12022
12023
12024 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12025 PyObject *resultobj;
12026 wxImage *arg1 = (wxImage *) 0 ;
12027 wxSize result;
12028 PyObject * obj0 = 0 ;
12029 char *kwnames[] = {
12030 (char *) "self", NULL
12031 };
12032
12033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12035 if (SWIG_arg_fail(1)) SWIG_fail;
12036 {
12037 PyThreadState* __tstate = wxPyBeginAllowThreads();
12038 result = wxImage_GetSize(arg1);
12039
12040 wxPyEndAllowThreads(__tstate);
12041 if (PyErr_Occurred()) SWIG_fail;
12042 }
12043 {
12044 wxSize * resultptr;
12045 resultptr = new wxSize((wxSize &)(result));
12046 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12047 }
12048 return resultobj;
12049 fail:
12050 return NULL;
12051 }
12052
12053
12054 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12055 PyObject *resultobj;
12056 wxImage *arg1 = (wxImage *) 0 ;
12057 wxRect *arg2 = 0 ;
12058 SwigValueWrapper<wxImage > result;
12059 wxRect temp2 ;
12060 PyObject * obj0 = 0 ;
12061 PyObject * obj1 = 0 ;
12062 char *kwnames[] = {
12063 (char *) "self",(char *) "rect", NULL
12064 };
12065
12066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12068 if (SWIG_arg_fail(1)) SWIG_fail;
12069 {
12070 arg2 = &temp2;
12071 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12072 }
12073 {
12074 PyThreadState* __tstate = wxPyBeginAllowThreads();
12075 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12076
12077 wxPyEndAllowThreads(__tstate);
12078 if (PyErr_Occurred()) SWIG_fail;
12079 }
12080 {
12081 wxImage * resultptr;
12082 resultptr = new wxImage((wxImage &)(result));
12083 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12084 }
12085 return resultobj;
12086 fail:
12087 return NULL;
12088 }
12089
12090
12091 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12092 PyObject *resultobj;
12093 wxImage *arg1 = (wxImage *) 0 ;
12094 SwigValueWrapper<wxImage > result;
12095 PyObject * obj0 = 0 ;
12096 char *kwnames[] = {
12097 (char *) "self", NULL
12098 };
12099
12100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12102 if (SWIG_arg_fail(1)) SWIG_fail;
12103 {
12104 PyThreadState* __tstate = wxPyBeginAllowThreads();
12105 result = (arg1)->Copy();
12106
12107 wxPyEndAllowThreads(__tstate);
12108 if (PyErr_Occurred()) SWIG_fail;
12109 }
12110 {
12111 wxImage * resultptr;
12112 resultptr = new wxImage((wxImage &)(result));
12113 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12114 }
12115 return resultobj;
12116 fail:
12117 return NULL;
12118 }
12119
12120
12121 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12122 PyObject *resultobj;
12123 wxImage *arg1 = (wxImage *) 0 ;
12124 wxImage *arg2 = 0 ;
12125 int arg3 ;
12126 int arg4 ;
12127 PyObject * obj0 = 0 ;
12128 PyObject * obj1 = 0 ;
12129 PyObject * obj2 = 0 ;
12130 PyObject * obj3 = 0 ;
12131 char *kwnames[] = {
12132 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12133 };
12134
12135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12137 if (SWIG_arg_fail(1)) SWIG_fail;
12138 {
12139 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12140 if (SWIG_arg_fail(2)) SWIG_fail;
12141 if (arg2 == NULL) {
12142 SWIG_null_ref("wxImage");
12143 }
12144 if (SWIG_arg_fail(2)) SWIG_fail;
12145 }
12146 {
12147 arg3 = (int)(SWIG_As_int(obj2));
12148 if (SWIG_arg_fail(3)) SWIG_fail;
12149 }
12150 {
12151 arg4 = (int)(SWIG_As_int(obj3));
12152 if (SWIG_arg_fail(4)) SWIG_fail;
12153 }
12154 {
12155 PyThreadState* __tstate = wxPyBeginAllowThreads();
12156 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12157
12158 wxPyEndAllowThreads(__tstate);
12159 if (PyErr_Occurred()) SWIG_fail;
12160 }
12161 Py_INCREF(Py_None); resultobj = Py_None;
12162 return resultobj;
12163 fail:
12164 return NULL;
12165 }
12166
12167
12168 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12169 PyObject *resultobj;
12170 wxImage *arg1 = (wxImage *) 0 ;
12171 PyObject *result;
12172 PyObject * obj0 = 0 ;
12173 char *kwnames[] = {
12174 (char *) "self", NULL
12175 };
12176
12177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12179 if (SWIG_arg_fail(1)) SWIG_fail;
12180 {
12181 PyThreadState* __tstate = wxPyBeginAllowThreads();
12182 result = (PyObject *)wxImage_GetData(arg1);
12183
12184 wxPyEndAllowThreads(__tstate);
12185 if (PyErr_Occurred()) SWIG_fail;
12186 }
12187 resultobj = result;
12188 return resultobj;
12189 fail:
12190 return NULL;
12191 }
12192
12193
12194 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12195 PyObject *resultobj;
12196 wxImage *arg1 = (wxImage *) 0 ;
12197 PyObject *arg2 = (PyObject *) 0 ;
12198 PyObject * obj0 = 0 ;
12199 PyObject * obj1 = 0 ;
12200 char *kwnames[] = {
12201 (char *) "self",(char *) "data", NULL
12202 };
12203
12204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12206 if (SWIG_arg_fail(1)) SWIG_fail;
12207 arg2 = obj1;
12208 {
12209 PyThreadState* __tstate = wxPyBeginAllowThreads();
12210 wxImage_SetData(arg1,arg2);
12211
12212 wxPyEndAllowThreads(__tstate);
12213 if (PyErr_Occurred()) SWIG_fail;
12214 }
12215 Py_INCREF(Py_None); resultobj = Py_None;
12216 return resultobj;
12217 fail:
12218 return NULL;
12219 }
12220
12221
12222 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12223 PyObject *resultobj;
12224 wxImage *arg1 = (wxImage *) 0 ;
12225 PyObject *result;
12226 PyObject * obj0 = 0 ;
12227 char *kwnames[] = {
12228 (char *) "self", NULL
12229 };
12230
12231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12233 if (SWIG_arg_fail(1)) SWIG_fail;
12234 {
12235 PyThreadState* __tstate = wxPyBeginAllowThreads();
12236 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12237
12238 wxPyEndAllowThreads(__tstate);
12239 if (PyErr_Occurred()) SWIG_fail;
12240 }
12241 resultobj = result;
12242 return resultobj;
12243 fail:
12244 return NULL;
12245 }
12246
12247
12248 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12249 PyObject *resultobj;
12250 wxImage *arg1 = (wxImage *) 0 ;
12251 PyObject *arg2 = (PyObject *) 0 ;
12252 PyObject * obj0 = 0 ;
12253 PyObject * obj1 = 0 ;
12254 char *kwnames[] = {
12255 (char *) "self",(char *) "data", NULL
12256 };
12257
12258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12260 if (SWIG_arg_fail(1)) SWIG_fail;
12261 arg2 = obj1;
12262 {
12263 PyThreadState* __tstate = wxPyBeginAllowThreads();
12264 wxImage_SetDataBuffer(arg1,arg2);
12265
12266 wxPyEndAllowThreads(__tstate);
12267 if (PyErr_Occurred()) SWIG_fail;
12268 }
12269 Py_INCREF(Py_None); resultobj = Py_None;
12270 return resultobj;
12271 fail:
12272 return NULL;
12273 }
12274
12275
12276 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12277 PyObject *resultobj;
12278 wxImage *arg1 = (wxImage *) 0 ;
12279 PyObject *result;
12280 PyObject * obj0 = 0 ;
12281 char *kwnames[] = {
12282 (char *) "self", NULL
12283 };
12284
12285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12287 if (SWIG_arg_fail(1)) SWIG_fail;
12288 {
12289 PyThreadState* __tstate = wxPyBeginAllowThreads();
12290 result = (PyObject *)wxImage_GetAlphaData(arg1);
12291
12292 wxPyEndAllowThreads(__tstate);
12293 if (PyErr_Occurred()) SWIG_fail;
12294 }
12295 resultobj = result;
12296 return resultobj;
12297 fail:
12298 return NULL;
12299 }
12300
12301
12302 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12303 PyObject *resultobj;
12304 wxImage *arg1 = (wxImage *) 0 ;
12305 PyObject *arg2 = (PyObject *) 0 ;
12306 PyObject * obj0 = 0 ;
12307 PyObject * obj1 = 0 ;
12308 char *kwnames[] = {
12309 (char *) "self",(char *) "data", NULL
12310 };
12311
12312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12314 if (SWIG_arg_fail(1)) SWIG_fail;
12315 arg2 = obj1;
12316 {
12317 PyThreadState* __tstate = wxPyBeginAllowThreads();
12318 wxImage_SetAlphaData(arg1,arg2);
12319
12320 wxPyEndAllowThreads(__tstate);
12321 if (PyErr_Occurred()) SWIG_fail;
12322 }
12323 Py_INCREF(Py_None); resultobj = Py_None;
12324 return resultobj;
12325 fail:
12326 return NULL;
12327 }
12328
12329
12330 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12331 PyObject *resultobj;
12332 wxImage *arg1 = (wxImage *) 0 ;
12333 PyObject *result;
12334 PyObject * obj0 = 0 ;
12335 char *kwnames[] = {
12336 (char *) "self", NULL
12337 };
12338
12339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12341 if (SWIG_arg_fail(1)) SWIG_fail;
12342 {
12343 PyThreadState* __tstate = wxPyBeginAllowThreads();
12344 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12345
12346 wxPyEndAllowThreads(__tstate);
12347 if (PyErr_Occurred()) SWIG_fail;
12348 }
12349 resultobj = result;
12350 return resultobj;
12351 fail:
12352 return NULL;
12353 }
12354
12355
12356 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12357 PyObject *resultobj;
12358 wxImage *arg1 = (wxImage *) 0 ;
12359 PyObject *arg2 = (PyObject *) 0 ;
12360 PyObject * obj0 = 0 ;
12361 PyObject * obj1 = 0 ;
12362 char *kwnames[] = {
12363 (char *) "self",(char *) "data", NULL
12364 };
12365
12366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12368 if (SWIG_arg_fail(1)) SWIG_fail;
12369 arg2 = obj1;
12370 {
12371 PyThreadState* __tstate = wxPyBeginAllowThreads();
12372 wxImage_SetAlphaBuffer(arg1,arg2);
12373
12374 wxPyEndAllowThreads(__tstate);
12375 if (PyErr_Occurred()) SWIG_fail;
12376 }
12377 Py_INCREF(Py_None); resultobj = Py_None;
12378 return resultobj;
12379 fail:
12380 return NULL;
12381 }
12382
12383
12384 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12385 PyObject *resultobj;
12386 wxImage *arg1 = (wxImage *) 0 ;
12387 unsigned char arg2 ;
12388 unsigned char arg3 ;
12389 unsigned char arg4 ;
12390 PyObject * obj0 = 0 ;
12391 PyObject * obj1 = 0 ;
12392 PyObject * obj2 = 0 ;
12393 PyObject * obj3 = 0 ;
12394 char *kwnames[] = {
12395 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12396 };
12397
12398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12400 if (SWIG_arg_fail(1)) SWIG_fail;
12401 {
12402 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12403 if (SWIG_arg_fail(2)) SWIG_fail;
12404 }
12405 {
12406 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12407 if (SWIG_arg_fail(3)) SWIG_fail;
12408 }
12409 {
12410 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12411 if (SWIG_arg_fail(4)) SWIG_fail;
12412 }
12413 {
12414 PyThreadState* __tstate = wxPyBeginAllowThreads();
12415 (arg1)->SetMaskColour(arg2,arg3,arg4);
12416
12417 wxPyEndAllowThreads(__tstate);
12418 if (PyErr_Occurred()) SWIG_fail;
12419 }
12420 Py_INCREF(Py_None); resultobj = Py_None;
12421 return resultobj;
12422 fail:
12423 return NULL;
12424 }
12425
12426
12427 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12428 PyObject *resultobj;
12429 wxImage *arg1 = (wxImage *) 0 ;
12430 unsigned char result;
12431 PyObject * obj0 = 0 ;
12432 char *kwnames[] = {
12433 (char *) "self", NULL
12434 };
12435
12436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12438 if (SWIG_arg_fail(1)) SWIG_fail;
12439 {
12440 PyThreadState* __tstate = wxPyBeginAllowThreads();
12441 result = (unsigned char)(arg1)->GetMaskRed();
12442
12443 wxPyEndAllowThreads(__tstate);
12444 if (PyErr_Occurred()) SWIG_fail;
12445 }
12446 {
12447 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12448 }
12449 return resultobj;
12450 fail:
12451 return NULL;
12452 }
12453
12454
12455 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12456 PyObject *resultobj;
12457 wxImage *arg1 = (wxImage *) 0 ;
12458 unsigned char result;
12459 PyObject * obj0 = 0 ;
12460 char *kwnames[] = {
12461 (char *) "self", NULL
12462 };
12463
12464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12466 if (SWIG_arg_fail(1)) SWIG_fail;
12467 {
12468 PyThreadState* __tstate = wxPyBeginAllowThreads();
12469 result = (unsigned char)(arg1)->GetMaskGreen();
12470
12471 wxPyEndAllowThreads(__tstate);
12472 if (PyErr_Occurred()) SWIG_fail;
12473 }
12474 {
12475 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12476 }
12477 return resultobj;
12478 fail:
12479 return NULL;
12480 }
12481
12482
12483 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12484 PyObject *resultobj;
12485 wxImage *arg1 = (wxImage *) 0 ;
12486 unsigned char result;
12487 PyObject * obj0 = 0 ;
12488 char *kwnames[] = {
12489 (char *) "self", NULL
12490 };
12491
12492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12494 if (SWIG_arg_fail(1)) SWIG_fail;
12495 {
12496 PyThreadState* __tstate = wxPyBeginAllowThreads();
12497 result = (unsigned char)(arg1)->GetMaskBlue();
12498
12499 wxPyEndAllowThreads(__tstate);
12500 if (PyErr_Occurred()) SWIG_fail;
12501 }
12502 {
12503 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12504 }
12505 return resultobj;
12506 fail:
12507 return NULL;
12508 }
12509
12510
12511 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12512 PyObject *resultobj;
12513 wxImage *arg1 = (wxImage *) 0 ;
12514 bool arg2 = (bool) true ;
12515 PyObject * obj0 = 0 ;
12516 PyObject * obj1 = 0 ;
12517 char *kwnames[] = {
12518 (char *) "self",(char *) "mask", NULL
12519 };
12520
12521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12523 if (SWIG_arg_fail(1)) SWIG_fail;
12524 if (obj1) {
12525 {
12526 arg2 = (bool)(SWIG_As_bool(obj1));
12527 if (SWIG_arg_fail(2)) SWIG_fail;
12528 }
12529 }
12530 {
12531 PyThreadState* __tstate = wxPyBeginAllowThreads();
12532 (arg1)->SetMask(arg2);
12533
12534 wxPyEndAllowThreads(__tstate);
12535 if (PyErr_Occurred()) SWIG_fail;
12536 }
12537 Py_INCREF(Py_None); resultobj = Py_None;
12538 return resultobj;
12539 fail:
12540 return NULL;
12541 }
12542
12543
12544 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12545 PyObject *resultobj;
12546 wxImage *arg1 = (wxImage *) 0 ;
12547 bool result;
12548 PyObject * obj0 = 0 ;
12549 char *kwnames[] = {
12550 (char *) "self", NULL
12551 };
12552
12553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12555 if (SWIG_arg_fail(1)) SWIG_fail;
12556 {
12557 PyThreadState* __tstate = wxPyBeginAllowThreads();
12558 result = (bool)(arg1)->HasMask();
12559
12560 wxPyEndAllowThreads(__tstate);
12561 if (PyErr_Occurred()) SWIG_fail;
12562 }
12563 {
12564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12565 }
12566 return resultobj;
12567 fail:
12568 return NULL;
12569 }
12570
12571
12572 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12573 PyObject *resultobj;
12574 wxImage *arg1 = (wxImage *) 0 ;
12575 double arg2 ;
12576 wxPoint *arg3 = 0 ;
12577 bool arg4 = (bool) true ;
12578 wxPoint *arg5 = (wxPoint *) NULL ;
12579 SwigValueWrapper<wxImage > result;
12580 wxPoint temp3 ;
12581 PyObject * obj0 = 0 ;
12582 PyObject * obj1 = 0 ;
12583 PyObject * obj2 = 0 ;
12584 PyObject * obj3 = 0 ;
12585 PyObject * obj4 = 0 ;
12586 char *kwnames[] = {
12587 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12588 };
12589
12590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12592 if (SWIG_arg_fail(1)) SWIG_fail;
12593 {
12594 arg2 = (double)(SWIG_As_double(obj1));
12595 if (SWIG_arg_fail(2)) SWIG_fail;
12596 }
12597 {
12598 arg3 = &temp3;
12599 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12600 }
12601 if (obj3) {
12602 {
12603 arg4 = (bool)(SWIG_As_bool(obj3));
12604 if (SWIG_arg_fail(4)) SWIG_fail;
12605 }
12606 }
12607 if (obj4) {
12608 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12609 if (SWIG_arg_fail(5)) SWIG_fail;
12610 }
12611 {
12612 PyThreadState* __tstate = wxPyBeginAllowThreads();
12613 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12614
12615 wxPyEndAllowThreads(__tstate);
12616 if (PyErr_Occurred()) SWIG_fail;
12617 }
12618 {
12619 wxImage * resultptr;
12620 resultptr = new wxImage((wxImage &)(result));
12621 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12622 }
12623 return resultobj;
12624 fail:
12625 return NULL;
12626 }
12627
12628
12629 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12630 PyObject *resultobj;
12631 wxImage *arg1 = (wxImage *) 0 ;
12632 bool arg2 = (bool) true ;
12633 SwigValueWrapper<wxImage > result;
12634 PyObject * obj0 = 0 ;
12635 PyObject * obj1 = 0 ;
12636 char *kwnames[] = {
12637 (char *) "self",(char *) "clockwise", NULL
12638 };
12639
12640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12642 if (SWIG_arg_fail(1)) SWIG_fail;
12643 if (obj1) {
12644 {
12645 arg2 = (bool)(SWIG_As_bool(obj1));
12646 if (SWIG_arg_fail(2)) SWIG_fail;
12647 }
12648 }
12649 {
12650 PyThreadState* __tstate = wxPyBeginAllowThreads();
12651 result = (arg1)->Rotate90(arg2);
12652
12653 wxPyEndAllowThreads(__tstate);
12654 if (PyErr_Occurred()) SWIG_fail;
12655 }
12656 {
12657 wxImage * resultptr;
12658 resultptr = new wxImage((wxImage &)(result));
12659 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12660 }
12661 return resultobj;
12662 fail:
12663 return NULL;
12664 }
12665
12666
12667 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12668 PyObject *resultobj;
12669 wxImage *arg1 = (wxImage *) 0 ;
12670 bool arg2 = (bool) true ;
12671 SwigValueWrapper<wxImage > result;
12672 PyObject * obj0 = 0 ;
12673 PyObject * obj1 = 0 ;
12674 char *kwnames[] = {
12675 (char *) "self",(char *) "horizontally", NULL
12676 };
12677
12678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12680 if (SWIG_arg_fail(1)) SWIG_fail;
12681 if (obj1) {
12682 {
12683 arg2 = (bool)(SWIG_As_bool(obj1));
12684 if (SWIG_arg_fail(2)) SWIG_fail;
12685 }
12686 }
12687 {
12688 PyThreadState* __tstate = wxPyBeginAllowThreads();
12689 result = (arg1)->Mirror(arg2);
12690
12691 wxPyEndAllowThreads(__tstate);
12692 if (PyErr_Occurred()) SWIG_fail;
12693 }
12694 {
12695 wxImage * resultptr;
12696 resultptr = new wxImage((wxImage &)(result));
12697 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12698 }
12699 return resultobj;
12700 fail:
12701 return NULL;
12702 }
12703
12704
12705 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12706 PyObject *resultobj;
12707 wxImage *arg1 = (wxImage *) 0 ;
12708 unsigned char arg2 ;
12709 unsigned char arg3 ;
12710 unsigned char arg4 ;
12711 unsigned char arg5 ;
12712 unsigned char arg6 ;
12713 unsigned char arg7 ;
12714 PyObject * obj0 = 0 ;
12715 PyObject * obj1 = 0 ;
12716 PyObject * obj2 = 0 ;
12717 PyObject * obj3 = 0 ;
12718 PyObject * obj4 = 0 ;
12719 PyObject * obj5 = 0 ;
12720 PyObject * obj6 = 0 ;
12721 char *kwnames[] = {
12722 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12723 };
12724
12725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12727 if (SWIG_arg_fail(1)) SWIG_fail;
12728 {
12729 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12730 if (SWIG_arg_fail(2)) SWIG_fail;
12731 }
12732 {
12733 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12734 if (SWIG_arg_fail(3)) SWIG_fail;
12735 }
12736 {
12737 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12738 if (SWIG_arg_fail(4)) SWIG_fail;
12739 }
12740 {
12741 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
12742 if (SWIG_arg_fail(5)) SWIG_fail;
12743 }
12744 {
12745 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
12746 if (SWIG_arg_fail(6)) SWIG_fail;
12747 }
12748 {
12749 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
12750 if (SWIG_arg_fail(7)) SWIG_fail;
12751 }
12752 {
12753 PyThreadState* __tstate = wxPyBeginAllowThreads();
12754 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
12755
12756 wxPyEndAllowThreads(__tstate);
12757 if (PyErr_Occurred()) SWIG_fail;
12758 }
12759 Py_INCREF(Py_None); resultobj = Py_None;
12760 return resultobj;
12761 fail:
12762 return NULL;
12763 }
12764
12765
12766 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
12767 PyObject *resultobj;
12768 wxImage *arg1 = (wxImage *) 0 ;
12769 unsigned char arg2 ;
12770 unsigned char arg3 ;
12771 unsigned char arg4 ;
12772 SwigValueWrapper<wxImage > result;
12773 PyObject * obj0 = 0 ;
12774 PyObject * obj1 = 0 ;
12775 PyObject * obj2 = 0 ;
12776 PyObject * obj3 = 0 ;
12777 char *kwnames[] = {
12778 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12779 };
12780
12781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12783 if (SWIG_arg_fail(1)) SWIG_fail;
12784 {
12785 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12786 if (SWIG_arg_fail(2)) SWIG_fail;
12787 }
12788 {
12789 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12790 if (SWIG_arg_fail(3)) SWIG_fail;
12791 }
12792 {
12793 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12794 if (SWIG_arg_fail(4)) SWIG_fail;
12795 }
12796 {
12797 PyThreadState* __tstate = wxPyBeginAllowThreads();
12798 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
12799
12800 wxPyEndAllowThreads(__tstate);
12801 if (PyErr_Occurred()) SWIG_fail;
12802 }
12803 {
12804 wxImage * resultptr;
12805 resultptr = new wxImage((wxImage &)(result));
12806 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12807 }
12808 return resultobj;
12809 fail:
12810 return NULL;
12811 }
12812
12813
12814 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12815 PyObject *resultobj;
12816 wxImage *arg1 = (wxImage *) 0 ;
12817 wxString *arg2 = 0 ;
12818 wxString *arg3 = 0 ;
12819 bool temp2 = false ;
12820 bool temp3 = false ;
12821 PyObject * obj0 = 0 ;
12822 PyObject * obj1 = 0 ;
12823 PyObject * obj2 = 0 ;
12824 char *kwnames[] = {
12825 (char *) "self",(char *) "name",(char *) "value", NULL
12826 };
12827
12828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
12829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12830 if (SWIG_arg_fail(1)) SWIG_fail;
12831 {
12832 arg2 = wxString_in_helper(obj1);
12833 if (arg2 == NULL) SWIG_fail;
12834 temp2 = true;
12835 }
12836 {
12837 arg3 = wxString_in_helper(obj2);
12838 if (arg3 == NULL) SWIG_fail;
12839 temp3 = true;
12840 }
12841 {
12842 PyThreadState* __tstate = wxPyBeginAllowThreads();
12843 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
12844
12845 wxPyEndAllowThreads(__tstate);
12846 if (PyErr_Occurred()) SWIG_fail;
12847 }
12848 Py_INCREF(Py_None); resultobj = Py_None;
12849 {
12850 if (temp2)
12851 delete arg2;
12852 }
12853 {
12854 if (temp3)
12855 delete arg3;
12856 }
12857 return resultobj;
12858 fail:
12859 {
12860 if (temp2)
12861 delete arg2;
12862 }
12863 {
12864 if (temp3)
12865 delete arg3;
12866 }
12867 return NULL;
12868 }
12869
12870
12871 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12872 PyObject *resultobj;
12873 wxImage *arg1 = (wxImage *) 0 ;
12874 wxString *arg2 = 0 ;
12875 int arg3 ;
12876 bool temp2 = false ;
12877 PyObject * obj0 = 0 ;
12878 PyObject * obj1 = 0 ;
12879 PyObject * obj2 = 0 ;
12880 char *kwnames[] = {
12881 (char *) "self",(char *) "name",(char *) "value", NULL
12882 };
12883
12884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
12885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12886 if (SWIG_arg_fail(1)) SWIG_fail;
12887 {
12888 arg2 = wxString_in_helper(obj1);
12889 if (arg2 == NULL) SWIG_fail;
12890 temp2 = true;
12891 }
12892 {
12893 arg3 = (int)(SWIG_As_int(obj2));
12894 if (SWIG_arg_fail(3)) SWIG_fail;
12895 }
12896 {
12897 PyThreadState* __tstate = wxPyBeginAllowThreads();
12898 (arg1)->SetOption((wxString const &)*arg2,arg3);
12899
12900 wxPyEndAllowThreads(__tstate);
12901 if (PyErr_Occurred()) SWIG_fail;
12902 }
12903 Py_INCREF(Py_None); resultobj = Py_None;
12904 {
12905 if (temp2)
12906 delete arg2;
12907 }
12908 return resultobj;
12909 fail:
12910 {
12911 if (temp2)
12912 delete arg2;
12913 }
12914 return NULL;
12915 }
12916
12917
12918 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12919 PyObject *resultobj;
12920 wxImage *arg1 = (wxImage *) 0 ;
12921 wxString *arg2 = 0 ;
12922 wxString result;
12923 bool temp2 = false ;
12924 PyObject * obj0 = 0 ;
12925 PyObject * obj1 = 0 ;
12926 char *kwnames[] = {
12927 (char *) "self",(char *) "name", NULL
12928 };
12929
12930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
12931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12932 if (SWIG_arg_fail(1)) SWIG_fail;
12933 {
12934 arg2 = wxString_in_helper(obj1);
12935 if (arg2 == NULL) SWIG_fail;
12936 temp2 = true;
12937 }
12938 {
12939 PyThreadState* __tstate = wxPyBeginAllowThreads();
12940 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
12941
12942 wxPyEndAllowThreads(__tstate);
12943 if (PyErr_Occurred()) SWIG_fail;
12944 }
12945 {
12946 #if wxUSE_UNICODE
12947 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12948 #else
12949 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12950 #endif
12951 }
12952 {
12953 if (temp2)
12954 delete arg2;
12955 }
12956 return resultobj;
12957 fail:
12958 {
12959 if (temp2)
12960 delete arg2;
12961 }
12962 return NULL;
12963 }
12964
12965
12966 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12967 PyObject *resultobj;
12968 wxImage *arg1 = (wxImage *) 0 ;
12969 wxString *arg2 = 0 ;
12970 int result;
12971 bool temp2 = false ;
12972 PyObject * obj0 = 0 ;
12973 PyObject * obj1 = 0 ;
12974 char *kwnames[] = {
12975 (char *) "self",(char *) "name", NULL
12976 };
12977
12978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
12979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12980 if (SWIG_arg_fail(1)) SWIG_fail;
12981 {
12982 arg2 = wxString_in_helper(obj1);
12983 if (arg2 == NULL) SWIG_fail;
12984 temp2 = true;
12985 }
12986 {
12987 PyThreadState* __tstate = wxPyBeginAllowThreads();
12988 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
12989
12990 wxPyEndAllowThreads(__tstate);
12991 if (PyErr_Occurred()) SWIG_fail;
12992 }
12993 {
12994 resultobj = SWIG_From_int((int)(result));
12995 }
12996 {
12997 if (temp2)
12998 delete arg2;
12999 }
13000 return resultobj;
13001 fail:
13002 {
13003 if (temp2)
13004 delete arg2;
13005 }
13006 return NULL;
13007 }
13008
13009
13010 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13011 PyObject *resultobj;
13012 wxImage *arg1 = (wxImage *) 0 ;
13013 wxString *arg2 = 0 ;
13014 bool result;
13015 bool temp2 = false ;
13016 PyObject * obj0 = 0 ;
13017 PyObject * obj1 = 0 ;
13018 char *kwnames[] = {
13019 (char *) "self",(char *) "name", NULL
13020 };
13021
13022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13024 if (SWIG_arg_fail(1)) SWIG_fail;
13025 {
13026 arg2 = wxString_in_helper(obj1);
13027 if (arg2 == NULL) SWIG_fail;
13028 temp2 = true;
13029 }
13030 {
13031 PyThreadState* __tstate = wxPyBeginAllowThreads();
13032 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13033
13034 wxPyEndAllowThreads(__tstate);
13035 if (PyErr_Occurred()) SWIG_fail;
13036 }
13037 {
13038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13039 }
13040 {
13041 if (temp2)
13042 delete arg2;
13043 }
13044 return resultobj;
13045 fail:
13046 {
13047 if (temp2)
13048 delete arg2;
13049 }
13050 return NULL;
13051 }
13052
13053
13054 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13055 PyObject *resultobj;
13056 wxImage *arg1 = (wxImage *) 0 ;
13057 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13058 unsigned long result;
13059 PyObject * obj0 = 0 ;
13060 PyObject * obj1 = 0 ;
13061 char *kwnames[] = {
13062 (char *) "self",(char *) "stopafter", NULL
13063 };
13064
13065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13067 if (SWIG_arg_fail(1)) SWIG_fail;
13068 if (obj1) {
13069 {
13070 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13071 if (SWIG_arg_fail(2)) SWIG_fail;
13072 }
13073 }
13074 {
13075 PyThreadState* __tstate = wxPyBeginAllowThreads();
13076 result = (unsigned long)(arg1)->CountColours(arg2);
13077
13078 wxPyEndAllowThreads(__tstate);
13079 if (PyErr_Occurred()) SWIG_fail;
13080 }
13081 {
13082 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13083 }
13084 return resultobj;
13085 fail:
13086 return NULL;
13087 }
13088
13089
13090 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13091 PyObject *resultobj;
13092 wxImage *arg1 = (wxImage *) 0 ;
13093 wxImageHistogram *arg2 = 0 ;
13094 unsigned long result;
13095 PyObject * obj0 = 0 ;
13096 PyObject * obj1 = 0 ;
13097 char *kwnames[] = {
13098 (char *) "self",(char *) "h", NULL
13099 };
13100
13101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13103 if (SWIG_arg_fail(1)) SWIG_fail;
13104 {
13105 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13106 if (SWIG_arg_fail(2)) SWIG_fail;
13107 if (arg2 == NULL) {
13108 SWIG_null_ref("wxImageHistogram");
13109 }
13110 if (SWIG_arg_fail(2)) SWIG_fail;
13111 }
13112 {
13113 PyThreadState* __tstate = wxPyBeginAllowThreads();
13114 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13115
13116 wxPyEndAllowThreads(__tstate);
13117 if (PyErr_Occurred()) SWIG_fail;
13118 }
13119 {
13120 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13121 }
13122 return resultobj;
13123 fail:
13124 return NULL;
13125 }
13126
13127
13128 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13129 PyObject *resultobj;
13130 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13131 PyObject * obj0 = 0 ;
13132 char *kwnames[] = {
13133 (char *) "handler", NULL
13134 };
13135
13136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13138 if (SWIG_arg_fail(1)) SWIG_fail;
13139 {
13140 PyThreadState* __tstate = wxPyBeginAllowThreads();
13141 wxImage::AddHandler(arg1);
13142
13143 wxPyEndAllowThreads(__tstate);
13144 if (PyErr_Occurred()) SWIG_fail;
13145 }
13146 Py_INCREF(Py_None); resultobj = Py_None;
13147 return resultobj;
13148 fail:
13149 return NULL;
13150 }
13151
13152
13153 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13154 PyObject *resultobj;
13155 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13156 PyObject * obj0 = 0 ;
13157 char *kwnames[] = {
13158 (char *) "handler", NULL
13159 };
13160
13161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13163 if (SWIG_arg_fail(1)) SWIG_fail;
13164 {
13165 PyThreadState* __tstate = wxPyBeginAllowThreads();
13166 wxImage::InsertHandler(arg1);
13167
13168 wxPyEndAllowThreads(__tstate);
13169 if (PyErr_Occurred()) SWIG_fail;
13170 }
13171 Py_INCREF(Py_None); resultobj = Py_None;
13172 return resultobj;
13173 fail:
13174 return NULL;
13175 }
13176
13177
13178 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13179 PyObject *resultobj;
13180 wxString *arg1 = 0 ;
13181 bool result;
13182 bool temp1 = false ;
13183 PyObject * obj0 = 0 ;
13184 char *kwnames[] = {
13185 (char *) "name", NULL
13186 };
13187
13188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13189 {
13190 arg1 = wxString_in_helper(obj0);
13191 if (arg1 == NULL) SWIG_fail;
13192 temp1 = true;
13193 }
13194 {
13195 PyThreadState* __tstate = wxPyBeginAllowThreads();
13196 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13197
13198 wxPyEndAllowThreads(__tstate);
13199 if (PyErr_Occurred()) SWIG_fail;
13200 }
13201 {
13202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13203 }
13204 {
13205 if (temp1)
13206 delete arg1;
13207 }
13208 return resultobj;
13209 fail:
13210 {
13211 if (temp1)
13212 delete arg1;
13213 }
13214 return NULL;
13215 }
13216
13217
13218 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13219 PyObject *resultobj;
13220 wxString result;
13221 char *kwnames[] = {
13222 NULL
13223 };
13224
13225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13226 {
13227 PyThreadState* __tstate = wxPyBeginAllowThreads();
13228 result = wxImage::GetImageExtWildcard();
13229
13230 wxPyEndAllowThreads(__tstate);
13231 if (PyErr_Occurred()) SWIG_fail;
13232 }
13233 {
13234 #if wxUSE_UNICODE
13235 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13236 #else
13237 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13238 #endif
13239 }
13240 return resultobj;
13241 fail:
13242 return NULL;
13243 }
13244
13245
13246 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13247 PyObject *resultobj;
13248 wxImage *arg1 = (wxImage *) 0 ;
13249 int arg2 = (int) -1 ;
13250 wxBitmap result;
13251 PyObject * obj0 = 0 ;
13252 PyObject * obj1 = 0 ;
13253 char *kwnames[] = {
13254 (char *) "self",(char *) "depth", NULL
13255 };
13256
13257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13259 if (SWIG_arg_fail(1)) SWIG_fail;
13260 if (obj1) {
13261 {
13262 arg2 = (int)(SWIG_As_int(obj1));
13263 if (SWIG_arg_fail(2)) SWIG_fail;
13264 }
13265 }
13266 {
13267 if (!wxPyCheckForApp()) SWIG_fail;
13268 PyThreadState* __tstate = wxPyBeginAllowThreads();
13269 result = wxImage_ConvertToBitmap(arg1,arg2);
13270
13271 wxPyEndAllowThreads(__tstate);
13272 if (PyErr_Occurred()) SWIG_fail;
13273 }
13274 {
13275 wxBitmap * resultptr;
13276 resultptr = new wxBitmap((wxBitmap &)(result));
13277 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13278 }
13279 return resultobj;
13280 fail:
13281 return NULL;
13282 }
13283
13284
13285 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13286 PyObject *resultobj;
13287 wxImage *arg1 = (wxImage *) 0 ;
13288 unsigned char arg2 ;
13289 unsigned char arg3 ;
13290 unsigned char arg4 ;
13291 wxBitmap result;
13292 PyObject * obj0 = 0 ;
13293 PyObject * obj1 = 0 ;
13294 PyObject * obj2 = 0 ;
13295 PyObject * obj3 = 0 ;
13296 char *kwnames[] = {
13297 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13298 };
13299
13300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13302 if (SWIG_arg_fail(1)) SWIG_fail;
13303 {
13304 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13305 if (SWIG_arg_fail(2)) SWIG_fail;
13306 }
13307 {
13308 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13309 if (SWIG_arg_fail(3)) SWIG_fail;
13310 }
13311 {
13312 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13313 if (SWIG_arg_fail(4)) SWIG_fail;
13314 }
13315 {
13316 if (!wxPyCheckForApp()) SWIG_fail;
13317 PyThreadState* __tstate = wxPyBeginAllowThreads();
13318 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13319
13320 wxPyEndAllowThreads(__tstate);
13321 if (PyErr_Occurred()) SWIG_fail;
13322 }
13323 {
13324 wxBitmap * resultptr;
13325 resultptr = new wxBitmap((wxBitmap &)(result));
13326 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13327 }
13328 return resultobj;
13329 fail:
13330 return NULL;
13331 }
13332
13333
13334 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13335 PyObject *obj;
13336 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13337 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13338 Py_INCREF(obj);
13339 return Py_BuildValue((char *)"");
13340 }
13341 static int _wrap_NullImage_set(PyObject *) {
13342 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13343 return 1;
13344 }
13345
13346
13347 static PyObject *_wrap_NullImage_get(void) {
13348 PyObject *pyobj;
13349
13350 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13351 return pyobj;
13352 }
13353
13354
13355 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13356 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13357 return 1;
13358 }
13359
13360
13361 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13362 PyObject *pyobj;
13363
13364 {
13365 #if wxUSE_UNICODE
13366 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13367 #else
13368 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13369 #endif
13370 }
13371 return pyobj;
13372 }
13373
13374
13375 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13376 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13377 return 1;
13378 }
13379
13380
13381 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13382 PyObject *pyobj;
13383
13384 {
13385 #if wxUSE_UNICODE
13386 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13387 #else
13388 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13389 #endif
13390 }
13391 return pyobj;
13392 }
13393
13394
13395 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13396 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13397 return 1;
13398 }
13399
13400
13401 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13402 PyObject *pyobj;
13403
13404 {
13405 #if wxUSE_UNICODE
13406 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13407 #else
13408 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13409 #endif
13410 }
13411 return pyobj;
13412 }
13413
13414
13415 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13416 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13417 return 1;
13418 }
13419
13420
13421 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13422 PyObject *pyobj;
13423
13424 {
13425 #if wxUSE_UNICODE
13426 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13427 #else
13428 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13429 #endif
13430 }
13431 return pyobj;
13432 }
13433
13434
13435 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13436 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13437 return 1;
13438 }
13439
13440
13441 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13442 PyObject *pyobj;
13443
13444 {
13445 #if wxUSE_UNICODE
13446 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13447 #else
13448 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13449 #endif
13450 }
13451 return pyobj;
13452 }
13453
13454
13455 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13456 PyObject *resultobj;
13457 wxBMPHandler *result;
13458 char *kwnames[] = {
13459 NULL
13460 };
13461
13462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13463 {
13464 PyThreadState* __tstate = wxPyBeginAllowThreads();
13465 result = (wxBMPHandler *)new wxBMPHandler();
13466
13467 wxPyEndAllowThreads(__tstate);
13468 if (PyErr_Occurred()) SWIG_fail;
13469 }
13470 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13471 return resultobj;
13472 fail:
13473 return NULL;
13474 }
13475
13476
13477 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13478 PyObject *obj;
13479 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13480 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13481 Py_INCREF(obj);
13482 return Py_BuildValue((char *)"");
13483 }
13484 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13485 PyObject *resultobj;
13486 wxICOHandler *result;
13487 char *kwnames[] = {
13488 NULL
13489 };
13490
13491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13492 {
13493 PyThreadState* __tstate = wxPyBeginAllowThreads();
13494 result = (wxICOHandler *)new wxICOHandler();
13495
13496 wxPyEndAllowThreads(__tstate);
13497 if (PyErr_Occurred()) SWIG_fail;
13498 }
13499 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13500 return resultobj;
13501 fail:
13502 return NULL;
13503 }
13504
13505
13506 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13507 PyObject *obj;
13508 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13509 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13510 Py_INCREF(obj);
13511 return Py_BuildValue((char *)"");
13512 }
13513 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13514 PyObject *resultobj;
13515 wxCURHandler *result;
13516 char *kwnames[] = {
13517 NULL
13518 };
13519
13520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13521 {
13522 PyThreadState* __tstate = wxPyBeginAllowThreads();
13523 result = (wxCURHandler *)new wxCURHandler();
13524
13525 wxPyEndAllowThreads(__tstate);
13526 if (PyErr_Occurred()) SWIG_fail;
13527 }
13528 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13529 return resultobj;
13530 fail:
13531 return NULL;
13532 }
13533
13534
13535 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
13536 PyObject *obj;
13537 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13538 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
13539 Py_INCREF(obj);
13540 return Py_BuildValue((char *)"");
13541 }
13542 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13543 PyObject *resultobj;
13544 wxANIHandler *result;
13545 char *kwnames[] = {
13546 NULL
13547 };
13548
13549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
13550 {
13551 PyThreadState* __tstate = wxPyBeginAllowThreads();
13552 result = (wxANIHandler *)new wxANIHandler();
13553
13554 wxPyEndAllowThreads(__tstate);
13555 if (PyErr_Occurred()) SWIG_fail;
13556 }
13557 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
13558 return resultobj;
13559 fail:
13560 return NULL;
13561 }
13562
13563
13564 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
13565 PyObject *obj;
13566 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13567 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
13568 Py_INCREF(obj);
13569 return Py_BuildValue((char *)"");
13570 }
13571 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13572 PyObject *resultobj;
13573 wxPNGHandler *result;
13574 char *kwnames[] = {
13575 NULL
13576 };
13577
13578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
13579 {
13580 PyThreadState* __tstate = wxPyBeginAllowThreads();
13581 result = (wxPNGHandler *)new wxPNGHandler();
13582
13583 wxPyEndAllowThreads(__tstate);
13584 if (PyErr_Occurred()) SWIG_fail;
13585 }
13586 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
13587 return resultobj;
13588 fail:
13589 return NULL;
13590 }
13591
13592
13593 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
13594 PyObject *obj;
13595 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13596 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
13597 Py_INCREF(obj);
13598 return Py_BuildValue((char *)"");
13599 }
13600 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13601 PyObject *resultobj;
13602 wxGIFHandler *result;
13603 char *kwnames[] = {
13604 NULL
13605 };
13606
13607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
13608 {
13609 PyThreadState* __tstate = wxPyBeginAllowThreads();
13610 result = (wxGIFHandler *)new wxGIFHandler();
13611
13612 wxPyEndAllowThreads(__tstate);
13613 if (PyErr_Occurred()) SWIG_fail;
13614 }
13615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
13616 return resultobj;
13617 fail:
13618 return NULL;
13619 }
13620
13621
13622 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
13623 PyObject *obj;
13624 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13625 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
13626 Py_INCREF(obj);
13627 return Py_BuildValue((char *)"");
13628 }
13629 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13630 PyObject *resultobj;
13631 wxPCXHandler *result;
13632 char *kwnames[] = {
13633 NULL
13634 };
13635
13636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
13637 {
13638 PyThreadState* __tstate = wxPyBeginAllowThreads();
13639 result = (wxPCXHandler *)new wxPCXHandler();
13640
13641 wxPyEndAllowThreads(__tstate);
13642 if (PyErr_Occurred()) SWIG_fail;
13643 }
13644 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
13645 return resultobj;
13646 fail:
13647 return NULL;
13648 }
13649
13650
13651 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
13652 PyObject *obj;
13653 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13654 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
13655 Py_INCREF(obj);
13656 return Py_BuildValue((char *)"");
13657 }
13658 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13659 PyObject *resultobj;
13660 wxJPEGHandler *result;
13661 char *kwnames[] = {
13662 NULL
13663 };
13664
13665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
13666 {
13667 PyThreadState* __tstate = wxPyBeginAllowThreads();
13668 result = (wxJPEGHandler *)new wxJPEGHandler();
13669
13670 wxPyEndAllowThreads(__tstate);
13671 if (PyErr_Occurred()) SWIG_fail;
13672 }
13673 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
13674 return resultobj;
13675 fail:
13676 return NULL;
13677 }
13678
13679
13680 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
13681 PyObject *obj;
13682 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13683 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
13684 Py_INCREF(obj);
13685 return Py_BuildValue((char *)"");
13686 }
13687 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13688 PyObject *resultobj;
13689 wxPNMHandler *result;
13690 char *kwnames[] = {
13691 NULL
13692 };
13693
13694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
13695 {
13696 PyThreadState* __tstate = wxPyBeginAllowThreads();
13697 result = (wxPNMHandler *)new wxPNMHandler();
13698
13699 wxPyEndAllowThreads(__tstate);
13700 if (PyErr_Occurred()) SWIG_fail;
13701 }
13702 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
13703 return resultobj;
13704 fail:
13705 return NULL;
13706 }
13707
13708
13709 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
13710 PyObject *obj;
13711 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13712 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
13713 Py_INCREF(obj);
13714 return Py_BuildValue((char *)"");
13715 }
13716 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13717 PyObject *resultobj;
13718 wxXPMHandler *result;
13719 char *kwnames[] = {
13720 NULL
13721 };
13722
13723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
13724 {
13725 PyThreadState* __tstate = wxPyBeginAllowThreads();
13726 result = (wxXPMHandler *)new wxXPMHandler();
13727
13728 wxPyEndAllowThreads(__tstate);
13729 if (PyErr_Occurred()) SWIG_fail;
13730 }
13731 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
13732 return resultobj;
13733 fail:
13734 return NULL;
13735 }
13736
13737
13738 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
13739 PyObject *obj;
13740 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13741 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
13742 Py_INCREF(obj);
13743 return Py_BuildValue((char *)"");
13744 }
13745 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13746 PyObject *resultobj;
13747 wxTIFFHandler *result;
13748 char *kwnames[] = {
13749 NULL
13750 };
13751
13752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
13753 {
13754 PyThreadState* __tstate = wxPyBeginAllowThreads();
13755 result = (wxTIFFHandler *)new wxTIFFHandler();
13756
13757 wxPyEndAllowThreads(__tstate);
13758 if (PyErr_Occurred()) SWIG_fail;
13759 }
13760 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
13761 return resultobj;
13762 fail:
13763 return NULL;
13764 }
13765
13766
13767 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
13768 PyObject *obj;
13769 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13770 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
13771 Py_INCREF(obj);
13772 return Py_BuildValue((char *)"");
13773 }
13774 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
13775 PyObject *resultobj;
13776 wxImage *arg1 = 0 ;
13777 wxImage *arg2 = 0 ;
13778 int arg3 = (int) 236 ;
13779 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
13780 bool result;
13781 PyObject * obj0 = 0 ;
13782 PyObject * obj1 = 0 ;
13783 PyObject * obj2 = 0 ;
13784 PyObject * obj3 = 0 ;
13785 char *kwnames[] = {
13786 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
13787 };
13788
13789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13790 {
13791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13792 if (SWIG_arg_fail(1)) SWIG_fail;
13793 if (arg1 == NULL) {
13794 SWIG_null_ref("wxImage");
13795 }
13796 if (SWIG_arg_fail(1)) SWIG_fail;
13797 }
13798 {
13799 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13800 if (SWIG_arg_fail(2)) SWIG_fail;
13801 if (arg2 == NULL) {
13802 SWIG_null_ref("wxImage");
13803 }
13804 if (SWIG_arg_fail(2)) SWIG_fail;
13805 }
13806 if (obj2) {
13807 {
13808 arg3 = (int)(SWIG_As_int(obj2));
13809 if (SWIG_arg_fail(3)) SWIG_fail;
13810 }
13811 }
13812 if (obj3) {
13813 {
13814 arg4 = (int)(SWIG_As_int(obj3));
13815 if (SWIG_arg_fail(4)) SWIG_fail;
13816 }
13817 }
13818 {
13819 PyThreadState* __tstate = wxPyBeginAllowThreads();
13820 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
13821
13822 wxPyEndAllowThreads(__tstate);
13823 if (PyErr_Occurred()) SWIG_fail;
13824 }
13825 {
13826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13827 }
13828 return resultobj;
13829 fail:
13830 return NULL;
13831 }
13832
13833
13834 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
13835 PyObject *obj;
13836 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13837 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
13838 Py_INCREF(obj);
13839 return Py_BuildValue((char *)"");
13840 }
13841 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13842 PyObject *resultobj;
13843 wxEvtHandler *result;
13844 char *kwnames[] = {
13845 NULL
13846 };
13847
13848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
13849 {
13850 PyThreadState* __tstate = wxPyBeginAllowThreads();
13851 result = (wxEvtHandler *)new wxEvtHandler();
13852
13853 wxPyEndAllowThreads(__tstate);
13854 if (PyErr_Occurred()) SWIG_fail;
13855 }
13856 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
13857 return resultobj;
13858 fail:
13859 return NULL;
13860 }
13861
13862
13863 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13864 PyObject *resultobj;
13865 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13866 wxEvtHandler *result;
13867 PyObject * obj0 = 0 ;
13868 char *kwnames[] = {
13869 (char *) "self", NULL
13870 };
13871
13872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
13873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13874 if (SWIG_arg_fail(1)) SWIG_fail;
13875 {
13876 PyThreadState* __tstate = wxPyBeginAllowThreads();
13877 result = (wxEvtHandler *)(arg1)->GetNextHandler();
13878
13879 wxPyEndAllowThreads(__tstate);
13880 if (PyErr_Occurred()) SWIG_fail;
13881 }
13882 {
13883 resultobj = wxPyMake_wxObject(result, 0);
13884 }
13885 return resultobj;
13886 fail:
13887 return NULL;
13888 }
13889
13890
13891 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13892 PyObject *resultobj;
13893 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13894 wxEvtHandler *result;
13895 PyObject * obj0 = 0 ;
13896 char *kwnames[] = {
13897 (char *) "self", NULL
13898 };
13899
13900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
13901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13902 if (SWIG_arg_fail(1)) SWIG_fail;
13903 {
13904 PyThreadState* __tstate = wxPyBeginAllowThreads();
13905 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
13906
13907 wxPyEndAllowThreads(__tstate);
13908 if (PyErr_Occurred()) SWIG_fail;
13909 }
13910 {
13911 resultobj = wxPyMake_wxObject(result, 0);
13912 }
13913 return resultobj;
13914 fail:
13915 return NULL;
13916 }
13917
13918
13919 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13920 PyObject *resultobj;
13921 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13922 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
13923 PyObject * obj0 = 0 ;
13924 PyObject * obj1 = 0 ;
13925 char *kwnames[] = {
13926 (char *) "self",(char *) "handler", NULL
13927 };
13928
13929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
13930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13931 if (SWIG_arg_fail(1)) SWIG_fail;
13932 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13933 if (SWIG_arg_fail(2)) SWIG_fail;
13934 {
13935 PyThreadState* __tstate = wxPyBeginAllowThreads();
13936 (arg1)->SetNextHandler(arg2);
13937
13938 wxPyEndAllowThreads(__tstate);
13939 if (PyErr_Occurred()) SWIG_fail;
13940 }
13941 Py_INCREF(Py_None); resultobj = Py_None;
13942 return resultobj;
13943 fail:
13944 return NULL;
13945 }
13946
13947
13948 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13949 PyObject *resultobj;
13950 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13951 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
13952 PyObject * obj0 = 0 ;
13953 PyObject * obj1 = 0 ;
13954 char *kwnames[] = {
13955 (char *) "self",(char *) "handler", NULL
13956 };
13957
13958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
13959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13960 if (SWIG_arg_fail(1)) SWIG_fail;
13961 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13962 if (SWIG_arg_fail(2)) SWIG_fail;
13963 {
13964 PyThreadState* __tstate = wxPyBeginAllowThreads();
13965 (arg1)->SetPreviousHandler(arg2);
13966
13967 wxPyEndAllowThreads(__tstate);
13968 if (PyErr_Occurred()) SWIG_fail;
13969 }
13970 Py_INCREF(Py_None); resultobj = Py_None;
13971 return resultobj;
13972 fail:
13973 return NULL;
13974 }
13975
13976
13977 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
13978 PyObject *resultobj;
13979 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13980 bool result;
13981 PyObject * obj0 = 0 ;
13982 char *kwnames[] = {
13983 (char *) "self", NULL
13984 };
13985
13986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
13987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13988 if (SWIG_arg_fail(1)) SWIG_fail;
13989 {
13990 PyThreadState* __tstate = wxPyBeginAllowThreads();
13991 result = (bool)(arg1)->GetEvtHandlerEnabled();
13992
13993 wxPyEndAllowThreads(__tstate);
13994 if (PyErr_Occurred()) SWIG_fail;
13995 }
13996 {
13997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13998 }
13999 return resultobj;
14000 fail:
14001 return NULL;
14002 }
14003
14004
14005 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14006 PyObject *resultobj;
14007 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14008 bool arg2 ;
14009 PyObject * obj0 = 0 ;
14010 PyObject * obj1 = 0 ;
14011 char *kwnames[] = {
14012 (char *) "self",(char *) "enabled", NULL
14013 };
14014
14015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14017 if (SWIG_arg_fail(1)) SWIG_fail;
14018 {
14019 arg2 = (bool)(SWIG_As_bool(obj1));
14020 if (SWIG_arg_fail(2)) SWIG_fail;
14021 }
14022 {
14023 PyThreadState* __tstate = wxPyBeginAllowThreads();
14024 (arg1)->SetEvtHandlerEnabled(arg2);
14025
14026 wxPyEndAllowThreads(__tstate);
14027 if (PyErr_Occurred()) SWIG_fail;
14028 }
14029 Py_INCREF(Py_None); resultobj = Py_None;
14030 return resultobj;
14031 fail:
14032 return NULL;
14033 }
14034
14035
14036 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14037 PyObject *resultobj;
14038 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14039 wxEvent *arg2 = 0 ;
14040 bool result;
14041 PyObject * obj0 = 0 ;
14042 PyObject * obj1 = 0 ;
14043 char *kwnames[] = {
14044 (char *) "self",(char *) "event", NULL
14045 };
14046
14047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14049 if (SWIG_arg_fail(1)) SWIG_fail;
14050 {
14051 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14052 if (SWIG_arg_fail(2)) SWIG_fail;
14053 if (arg2 == NULL) {
14054 SWIG_null_ref("wxEvent");
14055 }
14056 if (SWIG_arg_fail(2)) SWIG_fail;
14057 }
14058 {
14059 PyThreadState* __tstate = wxPyBeginAllowThreads();
14060 result = (bool)(arg1)->ProcessEvent(*arg2);
14061
14062 wxPyEndAllowThreads(__tstate);
14063 if (PyErr_Occurred()) SWIG_fail;
14064 }
14065 {
14066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14067 }
14068 return resultobj;
14069 fail:
14070 return NULL;
14071 }
14072
14073
14074 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14075 PyObject *resultobj;
14076 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14077 wxEvent *arg2 = 0 ;
14078 PyObject * obj0 = 0 ;
14079 PyObject * obj1 = 0 ;
14080 char *kwnames[] = {
14081 (char *) "self",(char *) "event", NULL
14082 };
14083
14084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14086 if (SWIG_arg_fail(1)) SWIG_fail;
14087 {
14088 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14089 if (SWIG_arg_fail(2)) SWIG_fail;
14090 if (arg2 == NULL) {
14091 SWIG_null_ref("wxEvent");
14092 }
14093 if (SWIG_arg_fail(2)) SWIG_fail;
14094 }
14095 {
14096 PyThreadState* __tstate = wxPyBeginAllowThreads();
14097 (arg1)->AddPendingEvent(*arg2);
14098
14099 wxPyEndAllowThreads(__tstate);
14100 if (PyErr_Occurred()) SWIG_fail;
14101 }
14102 Py_INCREF(Py_None); resultobj = Py_None;
14103 return resultobj;
14104 fail:
14105 return NULL;
14106 }
14107
14108
14109 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14110 PyObject *resultobj;
14111 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14112 PyObject * obj0 = 0 ;
14113 char *kwnames[] = {
14114 (char *) "self", NULL
14115 };
14116
14117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14119 if (SWIG_arg_fail(1)) SWIG_fail;
14120 {
14121 PyThreadState* __tstate = wxPyBeginAllowThreads();
14122 (arg1)->ProcessPendingEvents();
14123
14124 wxPyEndAllowThreads(__tstate);
14125 if (PyErr_Occurred()) SWIG_fail;
14126 }
14127 Py_INCREF(Py_None); resultobj = Py_None;
14128 return resultobj;
14129 fail:
14130 return NULL;
14131 }
14132
14133
14134 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14135 PyObject *resultobj;
14136 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14137 int arg2 ;
14138 int arg3 ;
14139 int arg4 ;
14140 PyObject *arg5 = (PyObject *) 0 ;
14141 PyObject * obj0 = 0 ;
14142 PyObject * obj1 = 0 ;
14143 PyObject * obj2 = 0 ;
14144 PyObject * obj3 = 0 ;
14145 PyObject * obj4 = 0 ;
14146 char *kwnames[] = {
14147 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14148 };
14149
14150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14152 if (SWIG_arg_fail(1)) SWIG_fail;
14153 {
14154 arg2 = (int)(SWIG_As_int(obj1));
14155 if (SWIG_arg_fail(2)) SWIG_fail;
14156 }
14157 {
14158 arg3 = (int)(SWIG_As_int(obj2));
14159 if (SWIG_arg_fail(3)) SWIG_fail;
14160 }
14161 {
14162 arg4 = (int)(SWIG_As_int(obj3));
14163 if (SWIG_arg_fail(4)) SWIG_fail;
14164 }
14165 arg5 = obj4;
14166 {
14167 PyThreadState* __tstate = wxPyBeginAllowThreads();
14168 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14169
14170 wxPyEndAllowThreads(__tstate);
14171 if (PyErr_Occurred()) SWIG_fail;
14172 }
14173 Py_INCREF(Py_None); resultobj = Py_None;
14174 return resultobj;
14175 fail:
14176 return NULL;
14177 }
14178
14179
14180 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14181 PyObject *resultobj;
14182 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14183 int arg2 ;
14184 int arg3 = (int) -1 ;
14185 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14186 bool result;
14187 PyObject * obj0 = 0 ;
14188 PyObject * obj1 = 0 ;
14189 PyObject * obj2 = 0 ;
14190 PyObject * obj3 = 0 ;
14191 char *kwnames[] = {
14192 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14193 };
14194
14195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14197 if (SWIG_arg_fail(1)) SWIG_fail;
14198 {
14199 arg2 = (int)(SWIG_As_int(obj1));
14200 if (SWIG_arg_fail(2)) SWIG_fail;
14201 }
14202 if (obj2) {
14203 {
14204 arg3 = (int)(SWIG_As_int(obj2));
14205 if (SWIG_arg_fail(3)) SWIG_fail;
14206 }
14207 }
14208 if (obj3) {
14209 {
14210 arg4 = (wxEventType)(SWIG_As_int(obj3));
14211 if (SWIG_arg_fail(4)) SWIG_fail;
14212 }
14213 }
14214 {
14215 PyThreadState* __tstate = wxPyBeginAllowThreads();
14216 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14217
14218 wxPyEndAllowThreads(__tstate);
14219 if (PyErr_Occurred()) SWIG_fail;
14220 }
14221 {
14222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14223 }
14224 return resultobj;
14225 fail:
14226 return NULL;
14227 }
14228
14229
14230 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14231 PyObject *resultobj;
14232 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14233 PyObject *arg2 = (PyObject *) 0 ;
14234 bool arg3 = (bool) true ;
14235 PyObject * obj0 = 0 ;
14236 PyObject * obj1 = 0 ;
14237 PyObject * obj2 = 0 ;
14238 char *kwnames[] = {
14239 (char *) "self",(char *) "_self",(char *) "incref", NULL
14240 };
14241
14242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14244 if (SWIG_arg_fail(1)) SWIG_fail;
14245 arg2 = obj1;
14246 if (obj2) {
14247 {
14248 arg3 = (bool)(SWIG_As_bool(obj2));
14249 if (SWIG_arg_fail(3)) SWIG_fail;
14250 }
14251 }
14252 {
14253 PyThreadState* __tstate = wxPyBeginAllowThreads();
14254 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14255
14256 wxPyEndAllowThreads(__tstate);
14257 if (PyErr_Occurred()) SWIG_fail;
14258 }
14259 Py_INCREF(Py_None); resultobj = Py_None;
14260 return resultobj;
14261 fail:
14262 return NULL;
14263 }
14264
14265
14266 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14267 PyObject *obj;
14268 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14269 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14270 Py_INCREF(obj);
14271 return Py_BuildValue((char *)"");
14272 }
14273 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14274 PyObject *resultobj;
14275 wxEventType result;
14276 char *kwnames[] = {
14277 NULL
14278 };
14279
14280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14281 {
14282 PyThreadState* __tstate = wxPyBeginAllowThreads();
14283 result = (wxEventType)wxNewEventType();
14284
14285 wxPyEndAllowThreads(__tstate);
14286 if (PyErr_Occurred()) SWIG_fail;
14287 }
14288 {
14289 resultobj = SWIG_From_int((int)(result));
14290 }
14291 return resultobj;
14292 fail:
14293 return NULL;
14294 }
14295
14296
14297 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14298 PyObject *resultobj;
14299 wxEvent *arg1 = (wxEvent *) 0 ;
14300 PyObject * obj0 = 0 ;
14301 char *kwnames[] = {
14302 (char *) "self", NULL
14303 };
14304
14305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14307 if (SWIG_arg_fail(1)) SWIG_fail;
14308 {
14309 PyThreadState* __tstate = wxPyBeginAllowThreads();
14310 delete arg1;
14311
14312 wxPyEndAllowThreads(__tstate);
14313 if (PyErr_Occurred()) SWIG_fail;
14314 }
14315 Py_INCREF(Py_None); resultobj = Py_None;
14316 return resultobj;
14317 fail:
14318 return NULL;
14319 }
14320
14321
14322 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14323 PyObject *resultobj;
14324 wxEvent *arg1 = (wxEvent *) 0 ;
14325 wxEventType arg2 ;
14326 PyObject * obj0 = 0 ;
14327 PyObject * obj1 = 0 ;
14328 char *kwnames[] = {
14329 (char *) "self",(char *) "typ", NULL
14330 };
14331
14332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14334 if (SWIG_arg_fail(1)) SWIG_fail;
14335 {
14336 arg2 = (wxEventType)(SWIG_As_int(obj1));
14337 if (SWIG_arg_fail(2)) SWIG_fail;
14338 }
14339 {
14340 PyThreadState* __tstate = wxPyBeginAllowThreads();
14341 (arg1)->SetEventType(arg2);
14342
14343 wxPyEndAllowThreads(__tstate);
14344 if (PyErr_Occurred()) SWIG_fail;
14345 }
14346 Py_INCREF(Py_None); resultobj = Py_None;
14347 return resultobj;
14348 fail:
14349 return NULL;
14350 }
14351
14352
14353 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14354 PyObject *resultobj;
14355 wxEvent *arg1 = (wxEvent *) 0 ;
14356 wxEventType result;
14357 PyObject * obj0 = 0 ;
14358 char *kwnames[] = {
14359 (char *) "self", NULL
14360 };
14361
14362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14364 if (SWIG_arg_fail(1)) SWIG_fail;
14365 {
14366 PyThreadState* __tstate = wxPyBeginAllowThreads();
14367 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14368
14369 wxPyEndAllowThreads(__tstate);
14370 if (PyErr_Occurred()) SWIG_fail;
14371 }
14372 {
14373 resultobj = SWIG_From_int((int)(result));
14374 }
14375 return resultobj;
14376 fail:
14377 return NULL;
14378 }
14379
14380
14381 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14382 PyObject *resultobj;
14383 wxEvent *arg1 = (wxEvent *) 0 ;
14384 wxObject *result;
14385 PyObject * obj0 = 0 ;
14386 char *kwnames[] = {
14387 (char *) "self", NULL
14388 };
14389
14390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14392 if (SWIG_arg_fail(1)) SWIG_fail;
14393 {
14394 PyThreadState* __tstate = wxPyBeginAllowThreads();
14395 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14396
14397 wxPyEndAllowThreads(__tstate);
14398 if (PyErr_Occurred()) SWIG_fail;
14399 }
14400 {
14401 resultobj = wxPyMake_wxObject(result, 0);
14402 }
14403 return resultobj;
14404 fail:
14405 return NULL;
14406 }
14407
14408
14409 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14410 PyObject *resultobj;
14411 wxEvent *arg1 = (wxEvent *) 0 ;
14412 wxObject *arg2 = (wxObject *) 0 ;
14413 PyObject * obj0 = 0 ;
14414 PyObject * obj1 = 0 ;
14415 char *kwnames[] = {
14416 (char *) "self",(char *) "obj", NULL
14417 };
14418
14419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14421 if (SWIG_arg_fail(1)) SWIG_fail;
14422 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14423 if (SWIG_arg_fail(2)) SWIG_fail;
14424 {
14425 PyThreadState* __tstate = wxPyBeginAllowThreads();
14426 (arg1)->SetEventObject(arg2);
14427
14428 wxPyEndAllowThreads(__tstate);
14429 if (PyErr_Occurred()) SWIG_fail;
14430 }
14431 Py_INCREF(Py_None); resultobj = Py_None;
14432 return resultobj;
14433 fail:
14434 return NULL;
14435 }
14436
14437
14438 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14439 PyObject *resultobj;
14440 wxEvent *arg1 = (wxEvent *) 0 ;
14441 long result;
14442 PyObject * obj0 = 0 ;
14443 char *kwnames[] = {
14444 (char *) "self", NULL
14445 };
14446
14447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14449 if (SWIG_arg_fail(1)) SWIG_fail;
14450 {
14451 PyThreadState* __tstate = wxPyBeginAllowThreads();
14452 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14453
14454 wxPyEndAllowThreads(__tstate);
14455 if (PyErr_Occurred()) SWIG_fail;
14456 }
14457 {
14458 resultobj = SWIG_From_long((long)(result));
14459 }
14460 return resultobj;
14461 fail:
14462 return NULL;
14463 }
14464
14465
14466 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14467 PyObject *resultobj;
14468 wxEvent *arg1 = (wxEvent *) 0 ;
14469 long arg2 = (long) 0 ;
14470 PyObject * obj0 = 0 ;
14471 PyObject * obj1 = 0 ;
14472 char *kwnames[] = {
14473 (char *) "self",(char *) "ts", NULL
14474 };
14475
14476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14478 if (SWIG_arg_fail(1)) SWIG_fail;
14479 if (obj1) {
14480 {
14481 arg2 = (long)(SWIG_As_long(obj1));
14482 if (SWIG_arg_fail(2)) SWIG_fail;
14483 }
14484 }
14485 {
14486 PyThreadState* __tstate = wxPyBeginAllowThreads();
14487 (arg1)->SetTimestamp(arg2);
14488
14489 wxPyEndAllowThreads(__tstate);
14490 if (PyErr_Occurred()) SWIG_fail;
14491 }
14492 Py_INCREF(Py_None); resultobj = Py_None;
14493 return resultobj;
14494 fail:
14495 return NULL;
14496 }
14497
14498
14499 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14500 PyObject *resultobj;
14501 wxEvent *arg1 = (wxEvent *) 0 ;
14502 int result;
14503 PyObject * obj0 = 0 ;
14504 char *kwnames[] = {
14505 (char *) "self", NULL
14506 };
14507
14508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14510 if (SWIG_arg_fail(1)) SWIG_fail;
14511 {
14512 PyThreadState* __tstate = wxPyBeginAllowThreads();
14513 result = (int)((wxEvent const *)arg1)->GetId();
14514
14515 wxPyEndAllowThreads(__tstate);
14516 if (PyErr_Occurred()) SWIG_fail;
14517 }
14518 {
14519 resultobj = SWIG_From_int((int)(result));
14520 }
14521 return resultobj;
14522 fail:
14523 return NULL;
14524 }
14525
14526
14527 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14528 PyObject *resultobj;
14529 wxEvent *arg1 = (wxEvent *) 0 ;
14530 int arg2 ;
14531 PyObject * obj0 = 0 ;
14532 PyObject * obj1 = 0 ;
14533 char *kwnames[] = {
14534 (char *) "self",(char *) "Id", NULL
14535 };
14536
14537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
14538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14539 if (SWIG_arg_fail(1)) SWIG_fail;
14540 {
14541 arg2 = (int)(SWIG_As_int(obj1));
14542 if (SWIG_arg_fail(2)) SWIG_fail;
14543 }
14544 {
14545 PyThreadState* __tstate = wxPyBeginAllowThreads();
14546 (arg1)->SetId(arg2);
14547
14548 wxPyEndAllowThreads(__tstate);
14549 if (PyErr_Occurred()) SWIG_fail;
14550 }
14551 Py_INCREF(Py_None); resultobj = Py_None;
14552 return resultobj;
14553 fail:
14554 return NULL;
14555 }
14556
14557
14558 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14559 PyObject *resultobj;
14560 wxEvent *arg1 = (wxEvent *) 0 ;
14561 bool result;
14562 PyObject * obj0 = 0 ;
14563 char *kwnames[] = {
14564 (char *) "self", NULL
14565 };
14566
14567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
14568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14569 if (SWIG_arg_fail(1)) SWIG_fail;
14570 {
14571 PyThreadState* __tstate = wxPyBeginAllowThreads();
14572 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
14573
14574 wxPyEndAllowThreads(__tstate);
14575 if (PyErr_Occurred()) SWIG_fail;
14576 }
14577 {
14578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14579 }
14580 return resultobj;
14581 fail:
14582 return NULL;
14583 }
14584
14585
14586 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
14587 PyObject *resultobj;
14588 wxEvent *arg1 = (wxEvent *) 0 ;
14589 bool arg2 = (bool) true ;
14590 PyObject * obj0 = 0 ;
14591 PyObject * obj1 = 0 ;
14592 char *kwnames[] = {
14593 (char *) "self",(char *) "skip", NULL
14594 };
14595
14596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
14597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14598 if (SWIG_arg_fail(1)) SWIG_fail;
14599 if (obj1) {
14600 {
14601 arg2 = (bool)(SWIG_As_bool(obj1));
14602 if (SWIG_arg_fail(2)) SWIG_fail;
14603 }
14604 }
14605 {
14606 PyThreadState* __tstate = wxPyBeginAllowThreads();
14607 (arg1)->Skip(arg2);
14608
14609 wxPyEndAllowThreads(__tstate);
14610 if (PyErr_Occurred()) SWIG_fail;
14611 }
14612 Py_INCREF(Py_None); resultobj = Py_None;
14613 return resultobj;
14614 fail:
14615 return NULL;
14616 }
14617
14618
14619 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
14620 PyObject *resultobj;
14621 wxEvent *arg1 = (wxEvent *) 0 ;
14622 bool result;
14623 PyObject * obj0 = 0 ;
14624 char *kwnames[] = {
14625 (char *) "self", NULL
14626 };
14627
14628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
14629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14630 if (SWIG_arg_fail(1)) SWIG_fail;
14631 {
14632 PyThreadState* __tstate = wxPyBeginAllowThreads();
14633 result = (bool)((wxEvent const *)arg1)->GetSkipped();
14634
14635 wxPyEndAllowThreads(__tstate);
14636 if (PyErr_Occurred()) SWIG_fail;
14637 }
14638 {
14639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14640 }
14641 return resultobj;
14642 fail:
14643 return NULL;
14644 }
14645
14646
14647 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
14648 PyObject *resultobj;
14649 wxEvent *arg1 = (wxEvent *) 0 ;
14650 bool result;
14651 PyObject * obj0 = 0 ;
14652 char *kwnames[] = {
14653 (char *) "self", NULL
14654 };
14655
14656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
14657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14658 if (SWIG_arg_fail(1)) SWIG_fail;
14659 {
14660 PyThreadState* __tstate = wxPyBeginAllowThreads();
14661 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
14662
14663 wxPyEndAllowThreads(__tstate);
14664 if (PyErr_Occurred()) SWIG_fail;
14665 }
14666 {
14667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14668 }
14669 return resultobj;
14670 fail:
14671 return NULL;
14672 }
14673
14674
14675 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14676 PyObject *resultobj;
14677 wxEvent *arg1 = (wxEvent *) 0 ;
14678 int result;
14679 PyObject * obj0 = 0 ;
14680 char *kwnames[] = {
14681 (char *) "self", NULL
14682 };
14683
14684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
14685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14686 if (SWIG_arg_fail(1)) SWIG_fail;
14687 {
14688 PyThreadState* __tstate = wxPyBeginAllowThreads();
14689 result = (int)(arg1)->StopPropagation();
14690
14691 wxPyEndAllowThreads(__tstate);
14692 if (PyErr_Occurred()) SWIG_fail;
14693 }
14694 {
14695 resultobj = SWIG_From_int((int)(result));
14696 }
14697 return resultobj;
14698 fail:
14699 return NULL;
14700 }
14701
14702
14703 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14704 PyObject *resultobj;
14705 wxEvent *arg1 = (wxEvent *) 0 ;
14706 int arg2 ;
14707 PyObject * obj0 = 0 ;
14708 PyObject * obj1 = 0 ;
14709 char *kwnames[] = {
14710 (char *) "self",(char *) "propagationLevel", NULL
14711 };
14712
14713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
14714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14715 if (SWIG_arg_fail(1)) SWIG_fail;
14716 {
14717 arg2 = (int)(SWIG_As_int(obj1));
14718 if (SWIG_arg_fail(2)) SWIG_fail;
14719 }
14720 {
14721 PyThreadState* __tstate = wxPyBeginAllowThreads();
14722 (arg1)->ResumePropagation(arg2);
14723
14724 wxPyEndAllowThreads(__tstate);
14725 if (PyErr_Occurred()) SWIG_fail;
14726 }
14727 Py_INCREF(Py_None); resultobj = Py_None;
14728 return resultobj;
14729 fail:
14730 return NULL;
14731 }
14732
14733
14734 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
14735 PyObject *resultobj;
14736 wxEvent *arg1 = (wxEvent *) 0 ;
14737 wxEvent *result;
14738 PyObject * obj0 = 0 ;
14739 char *kwnames[] = {
14740 (char *) "self", NULL
14741 };
14742
14743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
14744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14745 if (SWIG_arg_fail(1)) SWIG_fail;
14746 {
14747 PyThreadState* __tstate = wxPyBeginAllowThreads();
14748 result = (wxEvent *)(arg1)->Clone();
14749
14750 wxPyEndAllowThreads(__tstate);
14751 if (PyErr_Occurred()) SWIG_fail;
14752 }
14753 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
14754 return resultobj;
14755 fail:
14756 return NULL;
14757 }
14758
14759
14760 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
14761 PyObject *obj;
14762 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14763 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
14764 Py_INCREF(obj);
14765 return Py_BuildValue((char *)"");
14766 }
14767 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14768 PyObject *resultobj;
14769 wxEvent *arg1 = 0 ;
14770 wxPropagationDisabler *result;
14771 PyObject * obj0 = 0 ;
14772 char *kwnames[] = {
14773 (char *) "event", NULL
14774 };
14775
14776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
14777 {
14778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14779 if (SWIG_arg_fail(1)) SWIG_fail;
14780 if (arg1 == NULL) {
14781 SWIG_null_ref("wxEvent");
14782 }
14783 if (SWIG_arg_fail(1)) SWIG_fail;
14784 }
14785 {
14786 PyThreadState* __tstate = wxPyBeginAllowThreads();
14787 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
14788
14789 wxPyEndAllowThreads(__tstate);
14790 if (PyErr_Occurred()) SWIG_fail;
14791 }
14792 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
14793 return resultobj;
14794 fail:
14795 return NULL;
14796 }
14797
14798
14799 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14800 PyObject *resultobj;
14801 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
14802 PyObject * obj0 = 0 ;
14803 char *kwnames[] = {
14804 (char *) "self", NULL
14805 };
14806
14807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
14808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
14809 if (SWIG_arg_fail(1)) SWIG_fail;
14810 {
14811 PyThreadState* __tstate = wxPyBeginAllowThreads();
14812 delete arg1;
14813
14814 wxPyEndAllowThreads(__tstate);
14815 if (PyErr_Occurred()) SWIG_fail;
14816 }
14817 Py_INCREF(Py_None); resultobj = Py_None;
14818 return resultobj;
14819 fail:
14820 return NULL;
14821 }
14822
14823
14824 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
14825 PyObject *obj;
14826 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14827 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
14828 Py_INCREF(obj);
14829 return Py_BuildValue((char *)"");
14830 }
14831 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
14832 PyObject *resultobj;
14833 wxEvent *arg1 = 0 ;
14834 wxPropagateOnce *result;
14835 PyObject * obj0 = 0 ;
14836 char *kwnames[] = {
14837 (char *) "event", NULL
14838 };
14839
14840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
14841 {
14842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14843 if (SWIG_arg_fail(1)) SWIG_fail;
14844 if (arg1 == NULL) {
14845 SWIG_null_ref("wxEvent");
14846 }
14847 if (SWIG_arg_fail(1)) SWIG_fail;
14848 }
14849 {
14850 PyThreadState* __tstate = wxPyBeginAllowThreads();
14851 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
14852
14853 wxPyEndAllowThreads(__tstate);
14854 if (PyErr_Occurred()) SWIG_fail;
14855 }
14856 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
14857 return resultobj;
14858 fail:
14859 return NULL;
14860 }
14861
14862
14863 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
14864 PyObject *resultobj;
14865 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
14866 PyObject * obj0 = 0 ;
14867 char *kwnames[] = {
14868 (char *) "self", NULL
14869 };
14870
14871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
14872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
14873 if (SWIG_arg_fail(1)) SWIG_fail;
14874 {
14875 PyThreadState* __tstate = wxPyBeginAllowThreads();
14876 delete arg1;
14877
14878 wxPyEndAllowThreads(__tstate);
14879 if (PyErr_Occurred()) SWIG_fail;
14880 }
14881 Py_INCREF(Py_None); resultobj = Py_None;
14882 return resultobj;
14883 fail:
14884 return NULL;
14885 }
14886
14887
14888 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
14889 PyObject *obj;
14890 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14891 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
14892 Py_INCREF(obj);
14893 return Py_BuildValue((char *)"");
14894 }
14895 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14896 PyObject *resultobj;
14897 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
14898 int arg2 = (int) 0 ;
14899 wxCommandEvent *result;
14900 PyObject * obj0 = 0 ;
14901 PyObject * obj1 = 0 ;
14902 char *kwnames[] = {
14903 (char *) "commandType",(char *) "winid", NULL
14904 };
14905
14906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
14907 if (obj0) {
14908 {
14909 arg1 = (wxEventType)(SWIG_As_int(obj0));
14910 if (SWIG_arg_fail(1)) SWIG_fail;
14911 }
14912 }
14913 if (obj1) {
14914 {
14915 arg2 = (int)(SWIG_As_int(obj1));
14916 if (SWIG_arg_fail(2)) SWIG_fail;
14917 }
14918 }
14919 {
14920 PyThreadState* __tstate = wxPyBeginAllowThreads();
14921 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
14922
14923 wxPyEndAllowThreads(__tstate);
14924 if (PyErr_Occurred()) SWIG_fail;
14925 }
14926 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
14927 return resultobj;
14928 fail:
14929 return NULL;
14930 }
14931
14932
14933 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14934 PyObject *resultobj;
14935 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
14936 int result;
14937 PyObject * obj0 = 0 ;
14938 char *kwnames[] = {
14939 (char *) "self", NULL
14940 };
14941
14942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
14943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
14944 if (SWIG_arg_fail(1)) SWIG_fail;
14945 {
14946 PyThreadState* __tstate = wxPyBeginAllowThreads();
14947 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
14948
14949 wxPyEndAllowThreads(__tstate);
14950 if (PyErr_Occurred()) SWIG_fail;
14951 }
14952 {
14953 resultobj = SWIG_From_int((int)(result));
14954 }
14955 return resultobj;
14956 fail:
14957 return NULL;
14958 }
14959
14960
14961 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
14962 PyObject *resultobj;
14963 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
14964 wxString *arg2 = 0 ;
14965 bool temp2 = false ;
14966 PyObject * obj0 = 0 ;
14967 PyObject * obj1 = 0 ;
14968 char *kwnames[] = {
14969 (char *) "self",(char *) "s", NULL
14970 };
14971
14972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
14973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
14974 if (SWIG_arg_fail(1)) SWIG_fail;
14975 {
14976 arg2 = wxString_in_helper(obj1);
14977 if (arg2 == NULL) SWIG_fail;
14978 temp2 = true;
14979 }
14980 {
14981 PyThreadState* __tstate = wxPyBeginAllowThreads();
14982 (arg1)->SetString((wxString const &)*arg2);
14983
14984 wxPyEndAllowThreads(__tstate);
14985 if (PyErr_Occurred()) SWIG_fail;
14986 }
14987 Py_INCREF(Py_None); resultobj = Py_None;
14988 {
14989 if (temp2)
14990 delete arg2;
14991 }
14992 return resultobj;
14993 fail:
14994 {
14995 if (temp2)
14996 delete arg2;
14997 }
14998 return NULL;
14999 }
15000
15001
15002 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15003 PyObject *resultobj;
15004 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15005 wxString result;
15006 PyObject * obj0 = 0 ;
15007 char *kwnames[] = {
15008 (char *) "self", NULL
15009 };
15010
15011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15013 if (SWIG_arg_fail(1)) SWIG_fail;
15014 {
15015 PyThreadState* __tstate = wxPyBeginAllowThreads();
15016 result = ((wxCommandEvent const *)arg1)->GetString();
15017
15018 wxPyEndAllowThreads(__tstate);
15019 if (PyErr_Occurred()) SWIG_fail;
15020 }
15021 {
15022 #if wxUSE_UNICODE
15023 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15024 #else
15025 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15026 #endif
15027 }
15028 return resultobj;
15029 fail:
15030 return NULL;
15031 }
15032
15033
15034 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15035 PyObject *resultobj;
15036 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15037 bool result;
15038 PyObject * obj0 = 0 ;
15039 char *kwnames[] = {
15040 (char *) "self", NULL
15041 };
15042
15043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15045 if (SWIG_arg_fail(1)) SWIG_fail;
15046 {
15047 PyThreadState* __tstate = wxPyBeginAllowThreads();
15048 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15049
15050 wxPyEndAllowThreads(__tstate);
15051 if (PyErr_Occurred()) SWIG_fail;
15052 }
15053 {
15054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15055 }
15056 return resultobj;
15057 fail:
15058 return NULL;
15059 }
15060
15061
15062 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15063 PyObject *resultobj;
15064 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15065 bool result;
15066 PyObject * obj0 = 0 ;
15067 char *kwnames[] = {
15068 (char *) "self", NULL
15069 };
15070
15071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15073 if (SWIG_arg_fail(1)) SWIG_fail;
15074 {
15075 PyThreadState* __tstate = wxPyBeginAllowThreads();
15076 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15077
15078 wxPyEndAllowThreads(__tstate);
15079 if (PyErr_Occurred()) SWIG_fail;
15080 }
15081 {
15082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15083 }
15084 return resultobj;
15085 fail:
15086 return NULL;
15087 }
15088
15089
15090 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15091 PyObject *resultobj;
15092 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15093 long arg2 ;
15094 PyObject * obj0 = 0 ;
15095 PyObject * obj1 = 0 ;
15096 char *kwnames[] = {
15097 (char *) "self",(char *) "extraLong", NULL
15098 };
15099
15100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15102 if (SWIG_arg_fail(1)) SWIG_fail;
15103 {
15104 arg2 = (long)(SWIG_As_long(obj1));
15105 if (SWIG_arg_fail(2)) SWIG_fail;
15106 }
15107 {
15108 PyThreadState* __tstate = wxPyBeginAllowThreads();
15109 (arg1)->SetExtraLong(arg2);
15110
15111 wxPyEndAllowThreads(__tstate);
15112 if (PyErr_Occurred()) SWIG_fail;
15113 }
15114 Py_INCREF(Py_None); resultobj = Py_None;
15115 return resultobj;
15116 fail:
15117 return NULL;
15118 }
15119
15120
15121 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15122 PyObject *resultobj;
15123 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15124 long result;
15125 PyObject * obj0 = 0 ;
15126 char *kwnames[] = {
15127 (char *) "self", NULL
15128 };
15129
15130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15132 if (SWIG_arg_fail(1)) SWIG_fail;
15133 {
15134 PyThreadState* __tstate = wxPyBeginAllowThreads();
15135 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15136
15137 wxPyEndAllowThreads(__tstate);
15138 if (PyErr_Occurred()) SWIG_fail;
15139 }
15140 {
15141 resultobj = SWIG_From_long((long)(result));
15142 }
15143 return resultobj;
15144 fail:
15145 return NULL;
15146 }
15147
15148
15149 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15150 PyObject *resultobj;
15151 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15152 int arg2 ;
15153 PyObject * obj0 = 0 ;
15154 PyObject * obj1 = 0 ;
15155 char *kwnames[] = {
15156 (char *) "self",(char *) "i", NULL
15157 };
15158
15159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15161 if (SWIG_arg_fail(1)) SWIG_fail;
15162 {
15163 arg2 = (int)(SWIG_As_int(obj1));
15164 if (SWIG_arg_fail(2)) SWIG_fail;
15165 }
15166 {
15167 PyThreadState* __tstate = wxPyBeginAllowThreads();
15168 (arg1)->SetInt(arg2);
15169
15170 wxPyEndAllowThreads(__tstate);
15171 if (PyErr_Occurred()) SWIG_fail;
15172 }
15173 Py_INCREF(Py_None); resultobj = Py_None;
15174 return resultobj;
15175 fail:
15176 return NULL;
15177 }
15178
15179
15180 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15181 PyObject *resultobj;
15182 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15183 long result;
15184 PyObject * obj0 = 0 ;
15185 char *kwnames[] = {
15186 (char *) "self", NULL
15187 };
15188
15189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15191 if (SWIG_arg_fail(1)) SWIG_fail;
15192 {
15193 PyThreadState* __tstate = wxPyBeginAllowThreads();
15194 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15195
15196 wxPyEndAllowThreads(__tstate);
15197 if (PyErr_Occurred()) SWIG_fail;
15198 }
15199 {
15200 resultobj = SWIG_From_long((long)(result));
15201 }
15202 return resultobj;
15203 fail:
15204 return NULL;
15205 }
15206
15207
15208 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15209 PyObject *resultobj;
15210 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15211 wxEvent *result;
15212 PyObject * obj0 = 0 ;
15213 char *kwnames[] = {
15214 (char *) "self", NULL
15215 };
15216
15217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15219 if (SWIG_arg_fail(1)) SWIG_fail;
15220 {
15221 PyThreadState* __tstate = wxPyBeginAllowThreads();
15222 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15223
15224 wxPyEndAllowThreads(__tstate);
15225 if (PyErr_Occurred()) SWIG_fail;
15226 }
15227 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15228 return resultobj;
15229 fail:
15230 return NULL;
15231 }
15232
15233
15234 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15235 PyObject *obj;
15236 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15237 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15238 Py_INCREF(obj);
15239 return Py_BuildValue((char *)"");
15240 }
15241 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15242 PyObject *resultobj;
15243 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15244 int arg2 = (int) 0 ;
15245 wxNotifyEvent *result;
15246 PyObject * obj0 = 0 ;
15247 PyObject * obj1 = 0 ;
15248 char *kwnames[] = {
15249 (char *) "commandType",(char *) "winid", NULL
15250 };
15251
15252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15253 if (obj0) {
15254 {
15255 arg1 = (wxEventType)(SWIG_As_int(obj0));
15256 if (SWIG_arg_fail(1)) SWIG_fail;
15257 }
15258 }
15259 if (obj1) {
15260 {
15261 arg2 = (int)(SWIG_As_int(obj1));
15262 if (SWIG_arg_fail(2)) SWIG_fail;
15263 }
15264 }
15265 {
15266 PyThreadState* __tstate = wxPyBeginAllowThreads();
15267 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15268
15269 wxPyEndAllowThreads(__tstate);
15270 if (PyErr_Occurred()) SWIG_fail;
15271 }
15272 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15273 return resultobj;
15274 fail:
15275 return NULL;
15276 }
15277
15278
15279 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15280 PyObject *resultobj;
15281 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15282 PyObject * obj0 = 0 ;
15283 char *kwnames[] = {
15284 (char *) "self", NULL
15285 };
15286
15287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15289 if (SWIG_arg_fail(1)) SWIG_fail;
15290 {
15291 PyThreadState* __tstate = wxPyBeginAllowThreads();
15292 (arg1)->Veto();
15293
15294 wxPyEndAllowThreads(__tstate);
15295 if (PyErr_Occurred()) SWIG_fail;
15296 }
15297 Py_INCREF(Py_None); resultobj = Py_None;
15298 return resultobj;
15299 fail:
15300 return NULL;
15301 }
15302
15303
15304 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15305 PyObject *resultobj;
15306 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15307 PyObject * obj0 = 0 ;
15308 char *kwnames[] = {
15309 (char *) "self", NULL
15310 };
15311
15312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15314 if (SWIG_arg_fail(1)) SWIG_fail;
15315 {
15316 PyThreadState* __tstate = wxPyBeginAllowThreads();
15317 (arg1)->Allow();
15318
15319 wxPyEndAllowThreads(__tstate);
15320 if (PyErr_Occurred()) SWIG_fail;
15321 }
15322 Py_INCREF(Py_None); resultobj = Py_None;
15323 return resultobj;
15324 fail:
15325 return NULL;
15326 }
15327
15328
15329 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15330 PyObject *resultobj;
15331 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15332 bool result;
15333 PyObject * obj0 = 0 ;
15334 char *kwnames[] = {
15335 (char *) "self", NULL
15336 };
15337
15338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15340 if (SWIG_arg_fail(1)) SWIG_fail;
15341 {
15342 PyThreadState* __tstate = wxPyBeginAllowThreads();
15343 result = (bool)(arg1)->IsAllowed();
15344
15345 wxPyEndAllowThreads(__tstate);
15346 if (PyErr_Occurred()) SWIG_fail;
15347 }
15348 {
15349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15350 }
15351 return resultobj;
15352 fail:
15353 return NULL;
15354 }
15355
15356
15357 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15358 PyObject *obj;
15359 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15360 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15361 Py_INCREF(obj);
15362 return Py_BuildValue((char *)"");
15363 }
15364 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15365 PyObject *resultobj;
15366 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15367 int arg2 = (int) 0 ;
15368 int arg3 = (int) 0 ;
15369 int arg4 = (int) 0 ;
15370 wxScrollEvent *result;
15371 PyObject * obj0 = 0 ;
15372 PyObject * obj1 = 0 ;
15373 PyObject * obj2 = 0 ;
15374 PyObject * obj3 = 0 ;
15375 char *kwnames[] = {
15376 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15377 };
15378
15379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15380 if (obj0) {
15381 {
15382 arg1 = (wxEventType)(SWIG_As_int(obj0));
15383 if (SWIG_arg_fail(1)) SWIG_fail;
15384 }
15385 }
15386 if (obj1) {
15387 {
15388 arg2 = (int)(SWIG_As_int(obj1));
15389 if (SWIG_arg_fail(2)) SWIG_fail;
15390 }
15391 }
15392 if (obj2) {
15393 {
15394 arg3 = (int)(SWIG_As_int(obj2));
15395 if (SWIG_arg_fail(3)) SWIG_fail;
15396 }
15397 }
15398 if (obj3) {
15399 {
15400 arg4 = (int)(SWIG_As_int(obj3));
15401 if (SWIG_arg_fail(4)) SWIG_fail;
15402 }
15403 }
15404 {
15405 PyThreadState* __tstate = wxPyBeginAllowThreads();
15406 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15407
15408 wxPyEndAllowThreads(__tstate);
15409 if (PyErr_Occurred()) SWIG_fail;
15410 }
15411 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15412 return resultobj;
15413 fail:
15414 return NULL;
15415 }
15416
15417
15418 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15419 PyObject *resultobj;
15420 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15421 int result;
15422 PyObject * obj0 = 0 ;
15423 char *kwnames[] = {
15424 (char *) "self", NULL
15425 };
15426
15427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15429 if (SWIG_arg_fail(1)) SWIG_fail;
15430 {
15431 PyThreadState* __tstate = wxPyBeginAllowThreads();
15432 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15433
15434 wxPyEndAllowThreads(__tstate);
15435 if (PyErr_Occurred()) SWIG_fail;
15436 }
15437 {
15438 resultobj = SWIG_From_int((int)(result));
15439 }
15440 return resultobj;
15441 fail:
15442 return NULL;
15443 }
15444
15445
15446 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15447 PyObject *resultobj;
15448 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15449 int result;
15450 PyObject * obj0 = 0 ;
15451 char *kwnames[] = {
15452 (char *) "self", NULL
15453 };
15454
15455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15457 if (SWIG_arg_fail(1)) SWIG_fail;
15458 {
15459 PyThreadState* __tstate = wxPyBeginAllowThreads();
15460 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15461
15462 wxPyEndAllowThreads(__tstate);
15463 if (PyErr_Occurred()) SWIG_fail;
15464 }
15465 {
15466 resultobj = SWIG_From_int((int)(result));
15467 }
15468 return resultobj;
15469 fail:
15470 return NULL;
15471 }
15472
15473
15474 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15475 PyObject *resultobj;
15476 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15477 int arg2 ;
15478 PyObject * obj0 = 0 ;
15479 PyObject * obj1 = 0 ;
15480 char *kwnames[] = {
15481 (char *) "self",(char *) "orient", NULL
15482 };
15483
15484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15486 if (SWIG_arg_fail(1)) SWIG_fail;
15487 {
15488 arg2 = (int)(SWIG_As_int(obj1));
15489 if (SWIG_arg_fail(2)) SWIG_fail;
15490 }
15491 {
15492 PyThreadState* __tstate = wxPyBeginAllowThreads();
15493 (arg1)->SetOrientation(arg2);
15494
15495 wxPyEndAllowThreads(__tstate);
15496 if (PyErr_Occurred()) SWIG_fail;
15497 }
15498 Py_INCREF(Py_None); resultobj = Py_None;
15499 return resultobj;
15500 fail:
15501 return NULL;
15502 }
15503
15504
15505 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15506 PyObject *resultobj;
15507 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15508 int arg2 ;
15509 PyObject * obj0 = 0 ;
15510 PyObject * obj1 = 0 ;
15511 char *kwnames[] = {
15512 (char *) "self",(char *) "pos", NULL
15513 };
15514
15515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15517 if (SWIG_arg_fail(1)) SWIG_fail;
15518 {
15519 arg2 = (int)(SWIG_As_int(obj1));
15520 if (SWIG_arg_fail(2)) SWIG_fail;
15521 }
15522 {
15523 PyThreadState* __tstate = wxPyBeginAllowThreads();
15524 (arg1)->SetPosition(arg2);
15525
15526 wxPyEndAllowThreads(__tstate);
15527 if (PyErr_Occurred()) SWIG_fail;
15528 }
15529 Py_INCREF(Py_None); resultobj = Py_None;
15530 return resultobj;
15531 fail:
15532 return NULL;
15533 }
15534
15535
15536 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
15537 PyObject *obj;
15538 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15539 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
15540 Py_INCREF(obj);
15541 return Py_BuildValue((char *)"");
15542 }
15543 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15544 PyObject *resultobj;
15545 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15546 int arg2 = (int) 0 ;
15547 int arg3 = (int) 0 ;
15548 wxScrollWinEvent *result;
15549 PyObject * obj0 = 0 ;
15550 PyObject * obj1 = 0 ;
15551 PyObject * obj2 = 0 ;
15552 char *kwnames[] = {
15553 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
15554 };
15555
15556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15557 if (obj0) {
15558 {
15559 arg1 = (wxEventType)(SWIG_As_int(obj0));
15560 if (SWIG_arg_fail(1)) SWIG_fail;
15561 }
15562 }
15563 if (obj1) {
15564 {
15565 arg2 = (int)(SWIG_As_int(obj1));
15566 if (SWIG_arg_fail(2)) SWIG_fail;
15567 }
15568 }
15569 if (obj2) {
15570 {
15571 arg3 = (int)(SWIG_As_int(obj2));
15572 if (SWIG_arg_fail(3)) SWIG_fail;
15573 }
15574 }
15575 {
15576 PyThreadState* __tstate = wxPyBeginAllowThreads();
15577 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
15578
15579 wxPyEndAllowThreads(__tstate);
15580 if (PyErr_Occurred()) SWIG_fail;
15581 }
15582 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
15583 return resultobj;
15584 fail:
15585 return NULL;
15586 }
15587
15588
15589 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15590 PyObject *resultobj;
15591 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15592 int result;
15593 PyObject * obj0 = 0 ;
15594 char *kwnames[] = {
15595 (char *) "self", NULL
15596 };
15597
15598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
15599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15600 if (SWIG_arg_fail(1)) SWIG_fail;
15601 {
15602 PyThreadState* __tstate = wxPyBeginAllowThreads();
15603 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
15604
15605 wxPyEndAllowThreads(__tstate);
15606 if (PyErr_Occurred()) SWIG_fail;
15607 }
15608 {
15609 resultobj = SWIG_From_int((int)(result));
15610 }
15611 return resultobj;
15612 fail:
15613 return NULL;
15614 }
15615
15616
15617 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15618 PyObject *resultobj;
15619 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15620 int result;
15621 PyObject * obj0 = 0 ;
15622 char *kwnames[] = {
15623 (char *) "self", NULL
15624 };
15625
15626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
15627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15628 if (SWIG_arg_fail(1)) SWIG_fail;
15629 {
15630 PyThreadState* __tstate = wxPyBeginAllowThreads();
15631 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
15632
15633 wxPyEndAllowThreads(__tstate);
15634 if (PyErr_Occurred()) SWIG_fail;
15635 }
15636 {
15637 resultobj = SWIG_From_int((int)(result));
15638 }
15639 return resultobj;
15640 fail:
15641 return NULL;
15642 }
15643
15644
15645 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15646 PyObject *resultobj;
15647 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15648 int arg2 ;
15649 PyObject * obj0 = 0 ;
15650 PyObject * obj1 = 0 ;
15651 char *kwnames[] = {
15652 (char *) "self",(char *) "orient", NULL
15653 };
15654
15655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15657 if (SWIG_arg_fail(1)) SWIG_fail;
15658 {
15659 arg2 = (int)(SWIG_As_int(obj1));
15660 if (SWIG_arg_fail(2)) SWIG_fail;
15661 }
15662 {
15663 PyThreadState* __tstate = wxPyBeginAllowThreads();
15664 (arg1)->SetOrientation(arg2);
15665
15666 wxPyEndAllowThreads(__tstate);
15667 if (PyErr_Occurred()) SWIG_fail;
15668 }
15669 Py_INCREF(Py_None); resultobj = Py_None;
15670 return resultobj;
15671 fail:
15672 return NULL;
15673 }
15674
15675
15676 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15677 PyObject *resultobj;
15678 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15679 int arg2 ;
15680 PyObject * obj0 = 0 ;
15681 PyObject * obj1 = 0 ;
15682 char *kwnames[] = {
15683 (char *) "self",(char *) "pos", NULL
15684 };
15685
15686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15688 if (SWIG_arg_fail(1)) SWIG_fail;
15689 {
15690 arg2 = (int)(SWIG_As_int(obj1));
15691 if (SWIG_arg_fail(2)) SWIG_fail;
15692 }
15693 {
15694 PyThreadState* __tstate = wxPyBeginAllowThreads();
15695 (arg1)->SetPosition(arg2);
15696
15697 wxPyEndAllowThreads(__tstate);
15698 if (PyErr_Occurred()) SWIG_fail;
15699 }
15700 Py_INCREF(Py_None); resultobj = Py_None;
15701 return resultobj;
15702 fail:
15703 return NULL;
15704 }
15705
15706
15707 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
15708 PyObject *obj;
15709 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15710 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
15711 Py_INCREF(obj);
15712 return Py_BuildValue((char *)"");
15713 }
15714 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15715 PyObject *resultobj;
15716 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15717 wxMouseEvent *result;
15718 PyObject * obj0 = 0 ;
15719 char *kwnames[] = {
15720 (char *) "mouseType", NULL
15721 };
15722
15723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
15724 if (obj0) {
15725 {
15726 arg1 = (wxEventType)(SWIG_As_int(obj0));
15727 if (SWIG_arg_fail(1)) SWIG_fail;
15728 }
15729 }
15730 {
15731 PyThreadState* __tstate = wxPyBeginAllowThreads();
15732 result = (wxMouseEvent *)new wxMouseEvent(arg1);
15733
15734 wxPyEndAllowThreads(__tstate);
15735 if (PyErr_Occurred()) SWIG_fail;
15736 }
15737 {
15738 resultobj = wxPyMake_wxObject(result, 1);
15739 }
15740 return resultobj;
15741 fail:
15742 return NULL;
15743 }
15744
15745
15746 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
15747 PyObject *resultobj;
15748 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15749 bool result;
15750 PyObject * obj0 = 0 ;
15751 char *kwnames[] = {
15752 (char *) "self", NULL
15753 };
15754
15755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
15756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15757 if (SWIG_arg_fail(1)) SWIG_fail;
15758 {
15759 PyThreadState* __tstate = wxPyBeginAllowThreads();
15760 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
15761
15762 wxPyEndAllowThreads(__tstate);
15763 if (PyErr_Occurred()) SWIG_fail;
15764 }
15765 {
15766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15767 }
15768 return resultobj;
15769 fail:
15770 return NULL;
15771 }
15772
15773
15774 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
15775 PyObject *resultobj;
15776 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15777 int arg2 = (int) wxMOUSE_BTN_ANY ;
15778 bool result;
15779 PyObject * obj0 = 0 ;
15780 PyObject * obj1 = 0 ;
15781 char *kwnames[] = {
15782 (char *) "self",(char *) "but", NULL
15783 };
15784
15785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
15786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15787 if (SWIG_arg_fail(1)) SWIG_fail;
15788 if (obj1) {
15789 {
15790 arg2 = (int)(SWIG_As_int(obj1));
15791 if (SWIG_arg_fail(2)) SWIG_fail;
15792 }
15793 }
15794 {
15795 PyThreadState* __tstate = wxPyBeginAllowThreads();
15796 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
15797
15798 wxPyEndAllowThreads(__tstate);
15799 if (PyErr_Occurred()) SWIG_fail;
15800 }
15801 {
15802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15803 }
15804 return resultobj;
15805 fail:
15806 return NULL;
15807 }
15808
15809
15810 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
15811 PyObject *resultobj;
15812 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15813 int arg2 = (int) wxMOUSE_BTN_ANY ;
15814 bool result;
15815 PyObject * obj0 = 0 ;
15816 PyObject * obj1 = 0 ;
15817 char *kwnames[] = {
15818 (char *) "self",(char *) "but", NULL
15819 };
15820
15821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
15822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15823 if (SWIG_arg_fail(1)) SWIG_fail;
15824 if (obj1) {
15825 {
15826 arg2 = (int)(SWIG_As_int(obj1));
15827 if (SWIG_arg_fail(2)) SWIG_fail;
15828 }
15829 }
15830 {
15831 PyThreadState* __tstate = wxPyBeginAllowThreads();
15832 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
15833
15834 wxPyEndAllowThreads(__tstate);
15835 if (PyErr_Occurred()) SWIG_fail;
15836 }
15837 {
15838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15839 }
15840 return resultobj;
15841 fail:
15842 return NULL;
15843 }
15844
15845
15846 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
15847 PyObject *resultobj;
15848 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15849 int arg2 = (int) wxMOUSE_BTN_ANY ;
15850 bool result;
15851 PyObject * obj0 = 0 ;
15852 PyObject * obj1 = 0 ;
15853 char *kwnames[] = {
15854 (char *) "self",(char *) "but", NULL
15855 };
15856
15857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
15858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15859 if (SWIG_arg_fail(1)) SWIG_fail;
15860 if (obj1) {
15861 {
15862 arg2 = (int)(SWIG_As_int(obj1));
15863 if (SWIG_arg_fail(2)) SWIG_fail;
15864 }
15865 }
15866 {
15867 PyThreadState* __tstate = wxPyBeginAllowThreads();
15868 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
15869
15870 wxPyEndAllowThreads(__tstate);
15871 if (PyErr_Occurred()) SWIG_fail;
15872 }
15873 {
15874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15875 }
15876 return resultobj;
15877 fail:
15878 return NULL;
15879 }
15880
15881
15882 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
15883 PyObject *resultobj;
15884 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15885 int arg2 ;
15886 bool result;
15887 PyObject * obj0 = 0 ;
15888 PyObject * obj1 = 0 ;
15889 char *kwnames[] = {
15890 (char *) "self",(char *) "but", NULL
15891 };
15892
15893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
15894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15895 if (SWIG_arg_fail(1)) SWIG_fail;
15896 {
15897 arg2 = (int)(SWIG_As_int(obj1));
15898 if (SWIG_arg_fail(2)) SWIG_fail;
15899 }
15900 {
15901 PyThreadState* __tstate = wxPyBeginAllowThreads();
15902 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
15903
15904 wxPyEndAllowThreads(__tstate);
15905 if (PyErr_Occurred()) SWIG_fail;
15906 }
15907 {
15908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15909 }
15910 return resultobj;
15911 fail:
15912 return NULL;
15913 }
15914
15915
15916 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
15917 PyObject *resultobj;
15918 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15919 int arg2 ;
15920 bool result;
15921 PyObject * obj0 = 0 ;
15922 PyObject * obj1 = 0 ;
15923 char *kwnames[] = {
15924 (char *) "self",(char *) "but", NULL
15925 };
15926
15927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
15928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15929 if (SWIG_arg_fail(1)) SWIG_fail;
15930 {
15931 arg2 = (int)(SWIG_As_int(obj1));
15932 if (SWIG_arg_fail(2)) SWIG_fail;
15933 }
15934 {
15935 PyThreadState* __tstate = wxPyBeginAllowThreads();
15936 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
15937
15938 wxPyEndAllowThreads(__tstate);
15939 if (PyErr_Occurred()) SWIG_fail;
15940 }
15941 {
15942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15943 }
15944 return resultobj;
15945 fail:
15946 return NULL;
15947 }
15948
15949
15950 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
15951 PyObject *resultobj;
15952 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15953 int result;
15954 PyObject * obj0 = 0 ;
15955 char *kwnames[] = {
15956 (char *) "self", NULL
15957 };
15958
15959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
15960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15961 if (SWIG_arg_fail(1)) SWIG_fail;
15962 {
15963 PyThreadState* __tstate = wxPyBeginAllowThreads();
15964 result = (int)((wxMouseEvent const *)arg1)->GetButton();
15965
15966 wxPyEndAllowThreads(__tstate);
15967 if (PyErr_Occurred()) SWIG_fail;
15968 }
15969 {
15970 resultobj = SWIG_From_int((int)(result));
15971 }
15972 return resultobj;
15973 fail:
15974 return NULL;
15975 }
15976
15977
15978 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
15979 PyObject *resultobj;
15980 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15981 bool result;
15982 PyObject * obj0 = 0 ;
15983 char *kwnames[] = {
15984 (char *) "self", NULL
15985 };
15986
15987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
15988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15989 if (SWIG_arg_fail(1)) SWIG_fail;
15990 {
15991 PyThreadState* __tstate = wxPyBeginAllowThreads();
15992 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
15993
15994 wxPyEndAllowThreads(__tstate);
15995 if (PyErr_Occurred()) SWIG_fail;
15996 }
15997 {
15998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15999 }
16000 return resultobj;
16001 fail:
16002 return NULL;
16003 }
16004
16005
16006 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16007 PyObject *resultobj;
16008 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16009 bool result;
16010 PyObject * obj0 = 0 ;
16011 char *kwnames[] = {
16012 (char *) "self", NULL
16013 };
16014
16015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16017 if (SWIG_arg_fail(1)) SWIG_fail;
16018 {
16019 PyThreadState* __tstate = wxPyBeginAllowThreads();
16020 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16021
16022 wxPyEndAllowThreads(__tstate);
16023 if (PyErr_Occurred()) SWIG_fail;
16024 }
16025 {
16026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16027 }
16028 return resultobj;
16029 fail:
16030 return NULL;
16031 }
16032
16033
16034 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16035 PyObject *resultobj;
16036 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16037 bool result;
16038 PyObject * obj0 = 0 ;
16039 char *kwnames[] = {
16040 (char *) "self", NULL
16041 };
16042
16043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16045 if (SWIG_arg_fail(1)) SWIG_fail;
16046 {
16047 PyThreadState* __tstate = wxPyBeginAllowThreads();
16048 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16049
16050 wxPyEndAllowThreads(__tstate);
16051 if (PyErr_Occurred()) SWIG_fail;
16052 }
16053 {
16054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16055 }
16056 return resultobj;
16057 fail:
16058 return NULL;
16059 }
16060
16061
16062 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16063 PyObject *resultobj;
16064 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16065 bool result;
16066 PyObject * obj0 = 0 ;
16067 char *kwnames[] = {
16068 (char *) "self", NULL
16069 };
16070
16071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16073 if (SWIG_arg_fail(1)) SWIG_fail;
16074 {
16075 PyThreadState* __tstate = wxPyBeginAllowThreads();
16076 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16077
16078 wxPyEndAllowThreads(__tstate);
16079 if (PyErr_Occurred()) SWIG_fail;
16080 }
16081 {
16082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16083 }
16084 return resultobj;
16085 fail:
16086 return NULL;
16087 }
16088
16089
16090 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16091 PyObject *resultobj;
16092 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16093 bool result;
16094 PyObject * obj0 = 0 ;
16095 char *kwnames[] = {
16096 (char *) "self", NULL
16097 };
16098
16099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16101 if (SWIG_arg_fail(1)) SWIG_fail;
16102 {
16103 PyThreadState* __tstate = wxPyBeginAllowThreads();
16104 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16105
16106 wxPyEndAllowThreads(__tstate);
16107 if (PyErr_Occurred()) SWIG_fail;
16108 }
16109 {
16110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16111 }
16112 return resultobj;
16113 fail:
16114 return NULL;
16115 }
16116
16117
16118 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16119 PyObject *resultobj;
16120 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16121 bool result;
16122 PyObject * obj0 = 0 ;
16123 char *kwnames[] = {
16124 (char *) "self", NULL
16125 };
16126
16127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16129 if (SWIG_arg_fail(1)) SWIG_fail;
16130 {
16131 PyThreadState* __tstate = wxPyBeginAllowThreads();
16132 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16133
16134 wxPyEndAllowThreads(__tstate);
16135 if (PyErr_Occurred()) SWIG_fail;
16136 }
16137 {
16138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16139 }
16140 return resultobj;
16141 fail:
16142 return NULL;
16143 }
16144
16145
16146 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16147 PyObject *resultobj;
16148 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16149 bool result;
16150 PyObject * obj0 = 0 ;
16151 char *kwnames[] = {
16152 (char *) "self", NULL
16153 };
16154
16155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16157 if (SWIG_arg_fail(1)) SWIG_fail;
16158 {
16159 PyThreadState* __tstate = wxPyBeginAllowThreads();
16160 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16161
16162 wxPyEndAllowThreads(__tstate);
16163 if (PyErr_Occurred()) SWIG_fail;
16164 }
16165 {
16166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16167 }
16168 return resultobj;
16169 fail:
16170 return NULL;
16171 }
16172
16173
16174 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16175 PyObject *resultobj;
16176 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16177 bool result;
16178 PyObject * obj0 = 0 ;
16179 char *kwnames[] = {
16180 (char *) "self", NULL
16181 };
16182
16183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16185 if (SWIG_arg_fail(1)) SWIG_fail;
16186 {
16187 PyThreadState* __tstate = wxPyBeginAllowThreads();
16188 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16189
16190 wxPyEndAllowThreads(__tstate);
16191 if (PyErr_Occurred()) SWIG_fail;
16192 }
16193 {
16194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16195 }
16196 return resultobj;
16197 fail:
16198 return NULL;
16199 }
16200
16201
16202 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16203 PyObject *resultobj;
16204 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16205 bool result;
16206 PyObject * obj0 = 0 ;
16207 char *kwnames[] = {
16208 (char *) "self", NULL
16209 };
16210
16211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16213 if (SWIG_arg_fail(1)) SWIG_fail;
16214 {
16215 PyThreadState* __tstate = wxPyBeginAllowThreads();
16216 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16217
16218 wxPyEndAllowThreads(__tstate);
16219 if (PyErr_Occurred()) SWIG_fail;
16220 }
16221 {
16222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16223 }
16224 return resultobj;
16225 fail:
16226 return NULL;
16227 }
16228
16229
16230 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16231 PyObject *resultobj;
16232 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16233 bool result;
16234 PyObject * obj0 = 0 ;
16235 char *kwnames[] = {
16236 (char *) "self", NULL
16237 };
16238
16239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16241 if (SWIG_arg_fail(1)) SWIG_fail;
16242 {
16243 PyThreadState* __tstate = wxPyBeginAllowThreads();
16244 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16245
16246 wxPyEndAllowThreads(__tstate);
16247 if (PyErr_Occurred()) SWIG_fail;
16248 }
16249 {
16250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16251 }
16252 return resultobj;
16253 fail:
16254 return NULL;
16255 }
16256
16257
16258 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16259 PyObject *resultobj;
16260 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16261 bool result;
16262 PyObject * obj0 = 0 ;
16263 char *kwnames[] = {
16264 (char *) "self", NULL
16265 };
16266
16267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16269 if (SWIG_arg_fail(1)) SWIG_fail;
16270 {
16271 PyThreadState* __tstate = wxPyBeginAllowThreads();
16272 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16273
16274 wxPyEndAllowThreads(__tstate);
16275 if (PyErr_Occurred()) SWIG_fail;
16276 }
16277 {
16278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16279 }
16280 return resultobj;
16281 fail:
16282 return NULL;
16283 }
16284
16285
16286 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16287 PyObject *resultobj;
16288 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16289 bool result;
16290 PyObject * obj0 = 0 ;
16291 char *kwnames[] = {
16292 (char *) "self", NULL
16293 };
16294
16295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16297 if (SWIG_arg_fail(1)) SWIG_fail;
16298 {
16299 PyThreadState* __tstate = wxPyBeginAllowThreads();
16300 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16301
16302 wxPyEndAllowThreads(__tstate);
16303 if (PyErr_Occurred()) SWIG_fail;
16304 }
16305 {
16306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16307 }
16308 return resultobj;
16309 fail:
16310 return NULL;
16311 }
16312
16313
16314 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16315 PyObject *resultobj;
16316 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16317 bool result;
16318 PyObject * obj0 = 0 ;
16319 char *kwnames[] = {
16320 (char *) "self", NULL
16321 };
16322
16323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16325 if (SWIG_arg_fail(1)) SWIG_fail;
16326 {
16327 PyThreadState* __tstate = wxPyBeginAllowThreads();
16328 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16329
16330 wxPyEndAllowThreads(__tstate);
16331 if (PyErr_Occurred()) SWIG_fail;
16332 }
16333 {
16334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16335 }
16336 return resultobj;
16337 fail:
16338 return NULL;
16339 }
16340
16341
16342 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16343 PyObject *resultobj;
16344 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16345 bool result;
16346 PyObject * obj0 = 0 ;
16347 char *kwnames[] = {
16348 (char *) "self", NULL
16349 };
16350
16351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16353 if (SWIG_arg_fail(1)) SWIG_fail;
16354 {
16355 PyThreadState* __tstate = wxPyBeginAllowThreads();
16356 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16357
16358 wxPyEndAllowThreads(__tstate);
16359 if (PyErr_Occurred()) SWIG_fail;
16360 }
16361 {
16362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16363 }
16364 return resultobj;
16365 fail:
16366 return NULL;
16367 }
16368
16369
16370 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16371 PyObject *resultobj;
16372 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16373 bool result;
16374 PyObject * obj0 = 0 ;
16375 char *kwnames[] = {
16376 (char *) "self", NULL
16377 };
16378
16379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16381 if (SWIG_arg_fail(1)) SWIG_fail;
16382 {
16383 PyThreadState* __tstate = wxPyBeginAllowThreads();
16384 result = (bool)(arg1)->LeftIsDown();
16385
16386 wxPyEndAllowThreads(__tstate);
16387 if (PyErr_Occurred()) SWIG_fail;
16388 }
16389 {
16390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16391 }
16392 return resultobj;
16393 fail:
16394 return NULL;
16395 }
16396
16397
16398 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16399 PyObject *resultobj;
16400 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16401 bool result;
16402 PyObject * obj0 = 0 ;
16403 char *kwnames[] = {
16404 (char *) "self", NULL
16405 };
16406
16407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16409 if (SWIG_arg_fail(1)) SWIG_fail;
16410 {
16411 PyThreadState* __tstate = wxPyBeginAllowThreads();
16412 result = (bool)(arg1)->MiddleIsDown();
16413
16414 wxPyEndAllowThreads(__tstate);
16415 if (PyErr_Occurred()) SWIG_fail;
16416 }
16417 {
16418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16419 }
16420 return resultobj;
16421 fail:
16422 return NULL;
16423 }
16424
16425
16426 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16427 PyObject *resultobj;
16428 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16429 bool result;
16430 PyObject * obj0 = 0 ;
16431 char *kwnames[] = {
16432 (char *) "self", NULL
16433 };
16434
16435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16437 if (SWIG_arg_fail(1)) SWIG_fail;
16438 {
16439 PyThreadState* __tstate = wxPyBeginAllowThreads();
16440 result = (bool)(arg1)->RightIsDown();
16441
16442 wxPyEndAllowThreads(__tstate);
16443 if (PyErr_Occurred()) SWIG_fail;
16444 }
16445 {
16446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16447 }
16448 return resultobj;
16449 fail:
16450 return NULL;
16451 }
16452
16453
16454 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16455 PyObject *resultobj;
16456 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16457 bool result;
16458 PyObject * obj0 = 0 ;
16459 char *kwnames[] = {
16460 (char *) "self", NULL
16461 };
16462
16463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16465 if (SWIG_arg_fail(1)) SWIG_fail;
16466 {
16467 PyThreadState* __tstate = wxPyBeginAllowThreads();
16468 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16469
16470 wxPyEndAllowThreads(__tstate);
16471 if (PyErr_Occurred()) SWIG_fail;
16472 }
16473 {
16474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16475 }
16476 return resultobj;
16477 fail:
16478 return NULL;
16479 }
16480
16481
16482 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16483 PyObject *resultobj;
16484 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16485 bool result;
16486 PyObject * obj0 = 0 ;
16487 char *kwnames[] = {
16488 (char *) "self", NULL
16489 };
16490
16491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16493 if (SWIG_arg_fail(1)) SWIG_fail;
16494 {
16495 PyThreadState* __tstate = wxPyBeginAllowThreads();
16496 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16497
16498 wxPyEndAllowThreads(__tstate);
16499 if (PyErr_Occurred()) SWIG_fail;
16500 }
16501 {
16502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16503 }
16504 return resultobj;
16505 fail:
16506 return NULL;
16507 }
16508
16509
16510 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16511 PyObject *resultobj;
16512 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16513 bool result;
16514 PyObject * obj0 = 0 ;
16515 char *kwnames[] = {
16516 (char *) "self", NULL
16517 };
16518
16519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16521 if (SWIG_arg_fail(1)) SWIG_fail;
16522 {
16523 PyThreadState* __tstate = wxPyBeginAllowThreads();
16524 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16525
16526 wxPyEndAllowThreads(__tstate);
16527 if (PyErr_Occurred()) SWIG_fail;
16528 }
16529 {
16530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16531 }
16532 return resultobj;
16533 fail:
16534 return NULL;
16535 }
16536
16537
16538 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
16539 PyObject *resultobj;
16540 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16541 bool result;
16542 PyObject * obj0 = 0 ;
16543 char *kwnames[] = {
16544 (char *) "self", NULL
16545 };
16546
16547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
16548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16549 if (SWIG_arg_fail(1)) SWIG_fail;
16550 {
16551 PyThreadState* __tstate = wxPyBeginAllowThreads();
16552 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
16553
16554 wxPyEndAllowThreads(__tstate);
16555 if (PyErr_Occurred()) SWIG_fail;
16556 }
16557 {
16558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16559 }
16560 return resultobj;
16561 fail:
16562 return NULL;
16563 }
16564
16565
16566 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16567 PyObject *resultobj;
16568 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16569 wxPoint result;
16570 PyObject * obj0 = 0 ;
16571 char *kwnames[] = {
16572 (char *) "self", NULL
16573 };
16574
16575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
16576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16577 if (SWIG_arg_fail(1)) SWIG_fail;
16578 {
16579 PyThreadState* __tstate = wxPyBeginAllowThreads();
16580 result = (arg1)->GetPosition();
16581
16582 wxPyEndAllowThreads(__tstate);
16583 if (PyErr_Occurred()) SWIG_fail;
16584 }
16585 {
16586 wxPoint * resultptr;
16587 resultptr = new wxPoint((wxPoint &)(result));
16588 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16589 }
16590 return resultobj;
16591 fail:
16592 return NULL;
16593 }
16594
16595
16596 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16597 PyObject *resultobj;
16598 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16599 long *arg2 = (long *) 0 ;
16600 long *arg3 = (long *) 0 ;
16601 long temp2 ;
16602 int res2 = 0 ;
16603 long temp3 ;
16604 int res3 = 0 ;
16605 PyObject * obj0 = 0 ;
16606 char *kwnames[] = {
16607 (char *) "self", NULL
16608 };
16609
16610 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16611 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
16613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16614 if (SWIG_arg_fail(1)) SWIG_fail;
16615 {
16616 PyThreadState* __tstate = wxPyBeginAllowThreads();
16617 (arg1)->GetPosition(arg2,arg3);
16618
16619 wxPyEndAllowThreads(__tstate);
16620 if (PyErr_Occurred()) SWIG_fail;
16621 }
16622 Py_INCREF(Py_None); resultobj = Py_None;
16623 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16624 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
16625 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16626 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
16627 return resultobj;
16628 fail:
16629 return NULL;
16630 }
16631
16632
16633 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16634 PyObject *resultobj;
16635 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16636 wxDC *arg2 = 0 ;
16637 wxPoint result;
16638 PyObject * obj0 = 0 ;
16639 PyObject * obj1 = 0 ;
16640 char *kwnames[] = {
16641 (char *) "self",(char *) "dc", NULL
16642 };
16643
16644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
16645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16646 if (SWIG_arg_fail(1)) SWIG_fail;
16647 {
16648 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16649 if (SWIG_arg_fail(2)) SWIG_fail;
16650 if (arg2 == NULL) {
16651 SWIG_null_ref("wxDC");
16652 }
16653 if (SWIG_arg_fail(2)) SWIG_fail;
16654 }
16655 {
16656 PyThreadState* __tstate = wxPyBeginAllowThreads();
16657 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
16658
16659 wxPyEndAllowThreads(__tstate);
16660 if (PyErr_Occurred()) SWIG_fail;
16661 }
16662 {
16663 wxPoint * resultptr;
16664 resultptr = new wxPoint((wxPoint &)(result));
16665 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16666 }
16667 return resultobj;
16668 fail:
16669 return NULL;
16670 }
16671
16672
16673 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
16674 PyObject *resultobj;
16675 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16676 int result;
16677 PyObject * obj0 = 0 ;
16678 char *kwnames[] = {
16679 (char *) "self", NULL
16680 };
16681
16682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
16683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16684 if (SWIG_arg_fail(1)) SWIG_fail;
16685 {
16686 PyThreadState* __tstate = wxPyBeginAllowThreads();
16687 result = (int)((wxMouseEvent const *)arg1)->GetX();
16688
16689 wxPyEndAllowThreads(__tstate);
16690 if (PyErr_Occurred()) SWIG_fail;
16691 }
16692 {
16693 resultobj = SWIG_From_int((int)(result));
16694 }
16695 return resultobj;
16696 fail:
16697 return NULL;
16698 }
16699
16700
16701 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
16702 PyObject *resultobj;
16703 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16704 int result;
16705 PyObject * obj0 = 0 ;
16706 char *kwnames[] = {
16707 (char *) "self", NULL
16708 };
16709
16710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
16711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16712 if (SWIG_arg_fail(1)) SWIG_fail;
16713 {
16714 PyThreadState* __tstate = wxPyBeginAllowThreads();
16715 result = (int)((wxMouseEvent const *)arg1)->GetY();
16716
16717 wxPyEndAllowThreads(__tstate);
16718 if (PyErr_Occurred()) SWIG_fail;
16719 }
16720 {
16721 resultobj = SWIG_From_int((int)(result));
16722 }
16723 return resultobj;
16724 fail:
16725 return NULL;
16726 }
16727
16728
16729 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
16730 PyObject *resultobj;
16731 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16732 int result;
16733 PyObject * obj0 = 0 ;
16734 char *kwnames[] = {
16735 (char *) "self", NULL
16736 };
16737
16738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
16739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16740 if (SWIG_arg_fail(1)) SWIG_fail;
16741 {
16742 PyThreadState* __tstate = wxPyBeginAllowThreads();
16743 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
16744
16745 wxPyEndAllowThreads(__tstate);
16746 if (PyErr_Occurred()) SWIG_fail;
16747 }
16748 {
16749 resultobj = SWIG_From_int((int)(result));
16750 }
16751 return resultobj;
16752 fail:
16753 return NULL;
16754 }
16755
16756
16757 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
16758 PyObject *resultobj;
16759 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16760 int result;
16761 PyObject * obj0 = 0 ;
16762 char *kwnames[] = {
16763 (char *) "self", NULL
16764 };
16765
16766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
16767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16768 if (SWIG_arg_fail(1)) SWIG_fail;
16769 {
16770 PyThreadState* __tstate = wxPyBeginAllowThreads();
16771 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
16772
16773 wxPyEndAllowThreads(__tstate);
16774 if (PyErr_Occurred()) SWIG_fail;
16775 }
16776 {
16777 resultobj = SWIG_From_int((int)(result));
16778 }
16779 return resultobj;
16780 fail:
16781 return NULL;
16782 }
16783
16784
16785 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
16786 PyObject *resultobj;
16787 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16788 int result;
16789 PyObject * obj0 = 0 ;
16790 char *kwnames[] = {
16791 (char *) "self", NULL
16792 };
16793
16794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
16795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16796 if (SWIG_arg_fail(1)) SWIG_fail;
16797 {
16798 PyThreadState* __tstate = wxPyBeginAllowThreads();
16799 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
16800
16801 wxPyEndAllowThreads(__tstate);
16802 if (PyErr_Occurred()) SWIG_fail;
16803 }
16804 {
16805 resultobj = SWIG_From_int((int)(result));
16806 }
16807 return resultobj;
16808 fail:
16809 return NULL;
16810 }
16811
16812
16813 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
16814 PyObject *resultobj;
16815 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16816 bool result;
16817 PyObject * obj0 = 0 ;
16818 char *kwnames[] = {
16819 (char *) "self", NULL
16820 };
16821
16822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
16823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16824 if (SWIG_arg_fail(1)) SWIG_fail;
16825 {
16826 PyThreadState* __tstate = wxPyBeginAllowThreads();
16827 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
16828
16829 wxPyEndAllowThreads(__tstate);
16830 if (PyErr_Occurred()) SWIG_fail;
16831 }
16832 {
16833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16834 }
16835 return resultobj;
16836 fail:
16837 return NULL;
16838 }
16839
16840
16841 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
16842 PyObject *resultobj;
16843 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16844 int arg2 ;
16845 PyObject * obj0 = 0 ;
16846 PyObject * obj1 = 0 ;
16847 char *kwnames[] = {
16848 (char *) "self",(char *) "m_x", NULL
16849 };
16850
16851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
16852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16853 if (SWIG_arg_fail(1)) SWIG_fail;
16854 {
16855 arg2 = (int)(SWIG_As_int(obj1));
16856 if (SWIG_arg_fail(2)) SWIG_fail;
16857 }
16858 if (arg1) (arg1)->m_x = arg2;
16859
16860 Py_INCREF(Py_None); resultobj = Py_None;
16861 return resultobj;
16862 fail:
16863 return NULL;
16864 }
16865
16866
16867 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
16868 PyObject *resultobj;
16869 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16870 int result;
16871 PyObject * obj0 = 0 ;
16872 char *kwnames[] = {
16873 (char *) "self", NULL
16874 };
16875
16876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
16877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16878 if (SWIG_arg_fail(1)) SWIG_fail;
16879 result = (int) ((arg1)->m_x);
16880
16881 {
16882 resultobj = SWIG_From_int((int)(result));
16883 }
16884 return resultobj;
16885 fail:
16886 return NULL;
16887 }
16888
16889
16890 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
16891 PyObject *resultobj;
16892 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16893 int arg2 ;
16894 PyObject * obj0 = 0 ;
16895 PyObject * obj1 = 0 ;
16896 char *kwnames[] = {
16897 (char *) "self",(char *) "m_y", NULL
16898 };
16899
16900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
16901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16902 if (SWIG_arg_fail(1)) SWIG_fail;
16903 {
16904 arg2 = (int)(SWIG_As_int(obj1));
16905 if (SWIG_arg_fail(2)) SWIG_fail;
16906 }
16907 if (arg1) (arg1)->m_y = arg2;
16908
16909 Py_INCREF(Py_None); resultobj = Py_None;
16910 return resultobj;
16911 fail:
16912 return NULL;
16913 }
16914
16915
16916 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
16917 PyObject *resultobj;
16918 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16919 int result;
16920 PyObject * obj0 = 0 ;
16921 char *kwnames[] = {
16922 (char *) "self", NULL
16923 };
16924
16925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
16926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16927 if (SWIG_arg_fail(1)) SWIG_fail;
16928 result = (int) ((arg1)->m_y);
16929
16930 {
16931 resultobj = SWIG_From_int((int)(result));
16932 }
16933 return resultobj;
16934 fail:
16935 return NULL;
16936 }
16937
16938
16939 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
16940 PyObject *resultobj;
16941 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16942 bool arg2 ;
16943 PyObject * obj0 = 0 ;
16944 PyObject * obj1 = 0 ;
16945 char *kwnames[] = {
16946 (char *) "self",(char *) "m_leftDown", NULL
16947 };
16948
16949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
16950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16951 if (SWIG_arg_fail(1)) SWIG_fail;
16952 {
16953 arg2 = (bool)(SWIG_As_bool(obj1));
16954 if (SWIG_arg_fail(2)) SWIG_fail;
16955 }
16956 if (arg1) (arg1)->m_leftDown = arg2;
16957
16958 Py_INCREF(Py_None); resultobj = Py_None;
16959 return resultobj;
16960 fail:
16961 return NULL;
16962 }
16963
16964
16965 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
16966 PyObject *resultobj;
16967 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16968 bool result;
16969 PyObject * obj0 = 0 ;
16970 char *kwnames[] = {
16971 (char *) "self", NULL
16972 };
16973
16974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
16975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16976 if (SWIG_arg_fail(1)) SWIG_fail;
16977 result = (bool) ((arg1)->m_leftDown);
16978
16979 {
16980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16981 }
16982 return resultobj;
16983 fail:
16984 return NULL;
16985 }
16986
16987
16988 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
16989 PyObject *resultobj;
16990 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16991 bool arg2 ;
16992 PyObject * obj0 = 0 ;
16993 PyObject * obj1 = 0 ;
16994 char *kwnames[] = {
16995 (char *) "self",(char *) "m_middleDown", NULL
16996 };
16997
16998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
16999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17000 if (SWIG_arg_fail(1)) SWIG_fail;
17001 {
17002 arg2 = (bool)(SWIG_As_bool(obj1));
17003 if (SWIG_arg_fail(2)) SWIG_fail;
17004 }
17005 if (arg1) (arg1)->m_middleDown = arg2;
17006
17007 Py_INCREF(Py_None); resultobj = Py_None;
17008 return resultobj;
17009 fail:
17010 return NULL;
17011 }
17012
17013
17014 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17015 PyObject *resultobj;
17016 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17017 bool result;
17018 PyObject * obj0 = 0 ;
17019 char *kwnames[] = {
17020 (char *) "self", NULL
17021 };
17022
17023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17025 if (SWIG_arg_fail(1)) SWIG_fail;
17026 result = (bool) ((arg1)->m_middleDown);
17027
17028 {
17029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17030 }
17031 return resultobj;
17032 fail:
17033 return NULL;
17034 }
17035
17036
17037 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17038 PyObject *resultobj;
17039 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17040 bool arg2 ;
17041 PyObject * obj0 = 0 ;
17042 PyObject * obj1 = 0 ;
17043 char *kwnames[] = {
17044 (char *) "self",(char *) "m_rightDown", NULL
17045 };
17046
17047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17049 if (SWIG_arg_fail(1)) SWIG_fail;
17050 {
17051 arg2 = (bool)(SWIG_As_bool(obj1));
17052 if (SWIG_arg_fail(2)) SWIG_fail;
17053 }
17054 if (arg1) (arg1)->m_rightDown = arg2;
17055
17056 Py_INCREF(Py_None); resultobj = Py_None;
17057 return resultobj;
17058 fail:
17059 return NULL;
17060 }
17061
17062
17063 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17064 PyObject *resultobj;
17065 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17066 bool result;
17067 PyObject * obj0 = 0 ;
17068 char *kwnames[] = {
17069 (char *) "self", NULL
17070 };
17071
17072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17074 if (SWIG_arg_fail(1)) SWIG_fail;
17075 result = (bool) ((arg1)->m_rightDown);
17076
17077 {
17078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17079 }
17080 return resultobj;
17081 fail:
17082 return NULL;
17083 }
17084
17085
17086 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17087 PyObject *resultobj;
17088 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17089 bool arg2 ;
17090 PyObject * obj0 = 0 ;
17091 PyObject * obj1 = 0 ;
17092 char *kwnames[] = {
17093 (char *) "self",(char *) "m_controlDown", NULL
17094 };
17095
17096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17098 if (SWIG_arg_fail(1)) SWIG_fail;
17099 {
17100 arg2 = (bool)(SWIG_As_bool(obj1));
17101 if (SWIG_arg_fail(2)) SWIG_fail;
17102 }
17103 if (arg1) (arg1)->m_controlDown = arg2;
17104
17105 Py_INCREF(Py_None); resultobj = Py_None;
17106 return resultobj;
17107 fail:
17108 return NULL;
17109 }
17110
17111
17112 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17113 PyObject *resultobj;
17114 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17115 bool result;
17116 PyObject * obj0 = 0 ;
17117 char *kwnames[] = {
17118 (char *) "self", NULL
17119 };
17120
17121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17123 if (SWIG_arg_fail(1)) SWIG_fail;
17124 result = (bool) ((arg1)->m_controlDown);
17125
17126 {
17127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17128 }
17129 return resultobj;
17130 fail:
17131 return NULL;
17132 }
17133
17134
17135 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17136 PyObject *resultobj;
17137 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17138 bool arg2 ;
17139 PyObject * obj0 = 0 ;
17140 PyObject * obj1 = 0 ;
17141 char *kwnames[] = {
17142 (char *) "self",(char *) "m_shiftDown", NULL
17143 };
17144
17145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17147 if (SWIG_arg_fail(1)) SWIG_fail;
17148 {
17149 arg2 = (bool)(SWIG_As_bool(obj1));
17150 if (SWIG_arg_fail(2)) SWIG_fail;
17151 }
17152 if (arg1) (arg1)->m_shiftDown = arg2;
17153
17154 Py_INCREF(Py_None); resultobj = Py_None;
17155 return resultobj;
17156 fail:
17157 return NULL;
17158 }
17159
17160
17161 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17162 PyObject *resultobj;
17163 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17164 bool result;
17165 PyObject * obj0 = 0 ;
17166 char *kwnames[] = {
17167 (char *) "self", NULL
17168 };
17169
17170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17172 if (SWIG_arg_fail(1)) SWIG_fail;
17173 result = (bool) ((arg1)->m_shiftDown);
17174
17175 {
17176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17177 }
17178 return resultobj;
17179 fail:
17180 return NULL;
17181 }
17182
17183
17184 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17185 PyObject *resultobj;
17186 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17187 bool arg2 ;
17188 PyObject * obj0 = 0 ;
17189 PyObject * obj1 = 0 ;
17190 char *kwnames[] = {
17191 (char *) "self",(char *) "m_altDown", NULL
17192 };
17193
17194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17196 if (SWIG_arg_fail(1)) SWIG_fail;
17197 {
17198 arg2 = (bool)(SWIG_As_bool(obj1));
17199 if (SWIG_arg_fail(2)) SWIG_fail;
17200 }
17201 if (arg1) (arg1)->m_altDown = arg2;
17202
17203 Py_INCREF(Py_None); resultobj = Py_None;
17204 return resultobj;
17205 fail:
17206 return NULL;
17207 }
17208
17209
17210 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17211 PyObject *resultobj;
17212 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17213 bool result;
17214 PyObject * obj0 = 0 ;
17215 char *kwnames[] = {
17216 (char *) "self", NULL
17217 };
17218
17219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17221 if (SWIG_arg_fail(1)) SWIG_fail;
17222 result = (bool) ((arg1)->m_altDown);
17223
17224 {
17225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17226 }
17227 return resultobj;
17228 fail:
17229 return NULL;
17230 }
17231
17232
17233 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17234 PyObject *resultobj;
17235 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17236 bool arg2 ;
17237 PyObject * obj0 = 0 ;
17238 PyObject * obj1 = 0 ;
17239 char *kwnames[] = {
17240 (char *) "self",(char *) "m_metaDown", NULL
17241 };
17242
17243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17245 if (SWIG_arg_fail(1)) SWIG_fail;
17246 {
17247 arg2 = (bool)(SWIG_As_bool(obj1));
17248 if (SWIG_arg_fail(2)) SWIG_fail;
17249 }
17250 if (arg1) (arg1)->m_metaDown = arg2;
17251
17252 Py_INCREF(Py_None); resultobj = Py_None;
17253 return resultobj;
17254 fail:
17255 return NULL;
17256 }
17257
17258
17259 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17260 PyObject *resultobj;
17261 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17262 bool result;
17263 PyObject * obj0 = 0 ;
17264 char *kwnames[] = {
17265 (char *) "self", NULL
17266 };
17267
17268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17270 if (SWIG_arg_fail(1)) SWIG_fail;
17271 result = (bool) ((arg1)->m_metaDown);
17272
17273 {
17274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17275 }
17276 return resultobj;
17277 fail:
17278 return NULL;
17279 }
17280
17281
17282 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17283 PyObject *resultobj;
17284 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17285 int arg2 ;
17286 PyObject * obj0 = 0 ;
17287 PyObject * obj1 = 0 ;
17288 char *kwnames[] = {
17289 (char *) "self",(char *) "m_wheelRotation", NULL
17290 };
17291
17292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17294 if (SWIG_arg_fail(1)) SWIG_fail;
17295 {
17296 arg2 = (int)(SWIG_As_int(obj1));
17297 if (SWIG_arg_fail(2)) SWIG_fail;
17298 }
17299 if (arg1) (arg1)->m_wheelRotation = arg2;
17300
17301 Py_INCREF(Py_None); resultobj = Py_None;
17302 return resultobj;
17303 fail:
17304 return NULL;
17305 }
17306
17307
17308 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17309 PyObject *resultobj;
17310 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17311 int result;
17312 PyObject * obj0 = 0 ;
17313 char *kwnames[] = {
17314 (char *) "self", NULL
17315 };
17316
17317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17319 if (SWIG_arg_fail(1)) SWIG_fail;
17320 result = (int) ((arg1)->m_wheelRotation);
17321
17322 {
17323 resultobj = SWIG_From_int((int)(result));
17324 }
17325 return resultobj;
17326 fail:
17327 return NULL;
17328 }
17329
17330
17331 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17332 PyObject *resultobj;
17333 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17334 int arg2 ;
17335 PyObject * obj0 = 0 ;
17336 PyObject * obj1 = 0 ;
17337 char *kwnames[] = {
17338 (char *) "self",(char *) "m_wheelDelta", NULL
17339 };
17340
17341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17343 if (SWIG_arg_fail(1)) SWIG_fail;
17344 {
17345 arg2 = (int)(SWIG_As_int(obj1));
17346 if (SWIG_arg_fail(2)) SWIG_fail;
17347 }
17348 if (arg1) (arg1)->m_wheelDelta = arg2;
17349
17350 Py_INCREF(Py_None); resultobj = Py_None;
17351 return resultobj;
17352 fail:
17353 return NULL;
17354 }
17355
17356
17357 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17358 PyObject *resultobj;
17359 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17360 int result;
17361 PyObject * obj0 = 0 ;
17362 char *kwnames[] = {
17363 (char *) "self", NULL
17364 };
17365
17366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17368 if (SWIG_arg_fail(1)) SWIG_fail;
17369 result = (int) ((arg1)->m_wheelDelta);
17370
17371 {
17372 resultobj = SWIG_From_int((int)(result));
17373 }
17374 return resultobj;
17375 fail:
17376 return NULL;
17377 }
17378
17379
17380 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17381 PyObject *resultobj;
17382 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17383 int arg2 ;
17384 PyObject * obj0 = 0 ;
17385 PyObject * obj1 = 0 ;
17386 char *kwnames[] = {
17387 (char *) "self",(char *) "m_linesPerAction", NULL
17388 };
17389
17390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17392 if (SWIG_arg_fail(1)) SWIG_fail;
17393 {
17394 arg2 = (int)(SWIG_As_int(obj1));
17395 if (SWIG_arg_fail(2)) SWIG_fail;
17396 }
17397 if (arg1) (arg1)->m_linesPerAction = arg2;
17398
17399 Py_INCREF(Py_None); resultobj = Py_None;
17400 return resultobj;
17401 fail:
17402 return NULL;
17403 }
17404
17405
17406 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17407 PyObject *resultobj;
17408 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17409 int result;
17410 PyObject * obj0 = 0 ;
17411 char *kwnames[] = {
17412 (char *) "self", NULL
17413 };
17414
17415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17417 if (SWIG_arg_fail(1)) SWIG_fail;
17418 result = (int) ((arg1)->m_linesPerAction);
17419
17420 {
17421 resultobj = SWIG_From_int((int)(result));
17422 }
17423 return resultobj;
17424 fail:
17425 return NULL;
17426 }
17427
17428
17429 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17430 PyObject *obj;
17431 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17432 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17433 Py_INCREF(obj);
17434 return Py_BuildValue((char *)"");
17435 }
17436 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17437 PyObject *resultobj;
17438 int arg1 = (int) 0 ;
17439 int arg2 = (int) 0 ;
17440 wxSetCursorEvent *result;
17441 PyObject * obj0 = 0 ;
17442 PyObject * obj1 = 0 ;
17443 char *kwnames[] = {
17444 (char *) "x",(char *) "y", NULL
17445 };
17446
17447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17448 if (obj0) {
17449 {
17450 arg1 = (int)(SWIG_As_int(obj0));
17451 if (SWIG_arg_fail(1)) SWIG_fail;
17452 }
17453 }
17454 if (obj1) {
17455 {
17456 arg2 = (int)(SWIG_As_int(obj1));
17457 if (SWIG_arg_fail(2)) SWIG_fail;
17458 }
17459 }
17460 {
17461 PyThreadState* __tstate = wxPyBeginAllowThreads();
17462 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17463
17464 wxPyEndAllowThreads(__tstate);
17465 if (PyErr_Occurred()) SWIG_fail;
17466 }
17467 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17468 return resultobj;
17469 fail:
17470 return NULL;
17471 }
17472
17473
17474 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17475 PyObject *resultobj;
17476 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17477 int result;
17478 PyObject * obj0 = 0 ;
17479 char *kwnames[] = {
17480 (char *) "self", NULL
17481 };
17482
17483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17485 if (SWIG_arg_fail(1)) SWIG_fail;
17486 {
17487 PyThreadState* __tstate = wxPyBeginAllowThreads();
17488 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17489
17490 wxPyEndAllowThreads(__tstate);
17491 if (PyErr_Occurred()) SWIG_fail;
17492 }
17493 {
17494 resultobj = SWIG_From_int((int)(result));
17495 }
17496 return resultobj;
17497 fail:
17498 return NULL;
17499 }
17500
17501
17502 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17503 PyObject *resultobj;
17504 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17505 int result;
17506 PyObject * obj0 = 0 ;
17507 char *kwnames[] = {
17508 (char *) "self", NULL
17509 };
17510
17511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17513 if (SWIG_arg_fail(1)) SWIG_fail;
17514 {
17515 PyThreadState* __tstate = wxPyBeginAllowThreads();
17516 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17517
17518 wxPyEndAllowThreads(__tstate);
17519 if (PyErr_Occurred()) SWIG_fail;
17520 }
17521 {
17522 resultobj = SWIG_From_int((int)(result));
17523 }
17524 return resultobj;
17525 fail:
17526 return NULL;
17527 }
17528
17529
17530 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17531 PyObject *resultobj;
17532 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17533 wxCursor *arg2 = 0 ;
17534 PyObject * obj0 = 0 ;
17535 PyObject * obj1 = 0 ;
17536 char *kwnames[] = {
17537 (char *) "self",(char *) "cursor", NULL
17538 };
17539
17540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
17541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17542 if (SWIG_arg_fail(1)) SWIG_fail;
17543 {
17544 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
17545 if (SWIG_arg_fail(2)) SWIG_fail;
17546 if (arg2 == NULL) {
17547 SWIG_null_ref("wxCursor");
17548 }
17549 if (SWIG_arg_fail(2)) SWIG_fail;
17550 }
17551 {
17552 PyThreadState* __tstate = wxPyBeginAllowThreads();
17553 (arg1)->SetCursor((wxCursor const &)*arg2);
17554
17555 wxPyEndAllowThreads(__tstate);
17556 if (PyErr_Occurred()) SWIG_fail;
17557 }
17558 Py_INCREF(Py_None); resultobj = Py_None;
17559 return resultobj;
17560 fail:
17561 return NULL;
17562 }
17563
17564
17565 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17566 PyObject *resultobj;
17567 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17568 wxCursor *result;
17569 PyObject * obj0 = 0 ;
17570 char *kwnames[] = {
17571 (char *) "self", NULL
17572 };
17573
17574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
17575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17576 if (SWIG_arg_fail(1)) SWIG_fail;
17577 {
17578 PyThreadState* __tstate = wxPyBeginAllowThreads();
17579 {
17580 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
17581 result = (wxCursor *) &_result_ref;
17582 }
17583
17584 wxPyEndAllowThreads(__tstate);
17585 if (PyErr_Occurred()) SWIG_fail;
17586 }
17587 {
17588 wxCursor* resultptr = new wxCursor(*result);
17589 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
17590 }
17591 return resultobj;
17592 fail:
17593 return NULL;
17594 }
17595
17596
17597 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17598 PyObject *resultobj;
17599 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17600 bool result;
17601 PyObject * obj0 = 0 ;
17602 char *kwnames[] = {
17603 (char *) "self", NULL
17604 };
17605
17606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
17607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17608 if (SWIG_arg_fail(1)) SWIG_fail;
17609 {
17610 PyThreadState* __tstate = wxPyBeginAllowThreads();
17611 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
17612
17613 wxPyEndAllowThreads(__tstate);
17614 if (PyErr_Occurred()) SWIG_fail;
17615 }
17616 {
17617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17618 }
17619 return resultobj;
17620 fail:
17621 return NULL;
17622 }
17623
17624
17625 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
17626 PyObject *obj;
17627 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17628 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
17629 Py_INCREF(obj);
17630 return Py_BuildValue((char *)"");
17631 }
17632 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17633 PyObject *resultobj;
17634 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17635 wxKeyEvent *result;
17636 PyObject * obj0 = 0 ;
17637 char *kwnames[] = {
17638 (char *) "keyType", NULL
17639 };
17640
17641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
17642 if (obj0) {
17643 {
17644 arg1 = (wxEventType)(SWIG_As_int(obj0));
17645 if (SWIG_arg_fail(1)) SWIG_fail;
17646 }
17647 }
17648 {
17649 PyThreadState* __tstate = wxPyBeginAllowThreads();
17650 result = (wxKeyEvent *)new wxKeyEvent(arg1);
17651
17652 wxPyEndAllowThreads(__tstate);
17653 if (PyErr_Occurred()) SWIG_fail;
17654 }
17655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
17656 return resultobj;
17657 fail:
17658 return NULL;
17659 }
17660
17661
17662 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17663 PyObject *resultobj;
17664 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17665 bool result;
17666 PyObject * obj0 = 0 ;
17667 char *kwnames[] = {
17668 (char *) "self", NULL
17669 };
17670
17671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
17672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17673 if (SWIG_arg_fail(1)) SWIG_fail;
17674 {
17675 PyThreadState* __tstate = wxPyBeginAllowThreads();
17676 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
17677
17678 wxPyEndAllowThreads(__tstate);
17679 if (PyErr_Occurred()) SWIG_fail;
17680 }
17681 {
17682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17683 }
17684 return resultobj;
17685 fail:
17686 return NULL;
17687 }
17688
17689
17690 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17691 PyObject *resultobj;
17692 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17693 bool result;
17694 PyObject * obj0 = 0 ;
17695 char *kwnames[] = {
17696 (char *) "self", NULL
17697 };
17698
17699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
17700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17701 if (SWIG_arg_fail(1)) SWIG_fail;
17702 {
17703 PyThreadState* __tstate = wxPyBeginAllowThreads();
17704 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
17705
17706 wxPyEndAllowThreads(__tstate);
17707 if (PyErr_Occurred()) SWIG_fail;
17708 }
17709 {
17710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17711 }
17712 return resultobj;
17713 fail:
17714 return NULL;
17715 }
17716
17717
17718 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17719 PyObject *resultobj;
17720 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17721 bool result;
17722 PyObject * obj0 = 0 ;
17723 char *kwnames[] = {
17724 (char *) "self", NULL
17725 };
17726
17727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
17728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17729 if (SWIG_arg_fail(1)) SWIG_fail;
17730 {
17731 PyThreadState* __tstate = wxPyBeginAllowThreads();
17732 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
17733
17734 wxPyEndAllowThreads(__tstate);
17735 if (PyErr_Occurred()) SWIG_fail;
17736 }
17737 {
17738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17739 }
17740 return resultobj;
17741 fail:
17742 return NULL;
17743 }
17744
17745
17746 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17747 PyObject *resultobj;
17748 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17749 bool result;
17750 PyObject * obj0 = 0 ;
17751 char *kwnames[] = {
17752 (char *) "self", NULL
17753 };
17754
17755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
17756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17757 if (SWIG_arg_fail(1)) SWIG_fail;
17758 {
17759 PyThreadState* __tstate = wxPyBeginAllowThreads();
17760 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
17761
17762 wxPyEndAllowThreads(__tstate);
17763 if (PyErr_Occurred()) SWIG_fail;
17764 }
17765 {
17766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17767 }
17768 return resultobj;
17769 fail:
17770 return NULL;
17771 }
17772
17773
17774 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17775 PyObject *resultobj;
17776 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17777 bool result;
17778 PyObject * obj0 = 0 ;
17779 char *kwnames[] = {
17780 (char *) "self", NULL
17781 };
17782
17783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
17784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17785 if (SWIG_arg_fail(1)) SWIG_fail;
17786 {
17787 PyThreadState* __tstate = wxPyBeginAllowThreads();
17788 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
17789
17790 wxPyEndAllowThreads(__tstate);
17791 if (PyErr_Occurred()) SWIG_fail;
17792 }
17793 {
17794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17795 }
17796 return resultobj;
17797 fail:
17798 return NULL;
17799 }
17800
17801
17802 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
17803 PyObject *resultobj;
17804 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17805 bool result;
17806 PyObject * obj0 = 0 ;
17807 char *kwnames[] = {
17808 (char *) "self", NULL
17809 };
17810
17811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
17812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17813 if (SWIG_arg_fail(1)) SWIG_fail;
17814 {
17815 PyThreadState* __tstate = wxPyBeginAllowThreads();
17816 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
17817
17818 wxPyEndAllowThreads(__tstate);
17819 if (PyErr_Occurred()) SWIG_fail;
17820 }
17821 {
17822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17823 }
17824 return resultobj;
17825 fail:
17826 return NULL;
17827 }
17828
17829
17830 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
17831 PyObject *resultobj;
17832 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17833 int result;
17834 PyObject * obj0 = 0 ;
17835 char *kwnames[] = {
17836 (char *) "self", NULL
17837 };
17838
17839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
17840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17841 if (SWIG_arg_fail(1)) SWIG_fail;
17842 {
17843 PyThreadState* __tstate = wxPyBeginAllowThreads();
17844 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
17845
17846 wxPyEndAllowThreads(__tstate);
17847 if (PyErr_Occurred()) SWIG_fail;
17848 }
17849 {
17850 resultobj = SWIG_From_int((int)(result));
17851 }
17852 return resultobj;
17853 fail:
17854 return NULL;
17855 }
17856
17857
17858 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
17859 PyObject *resultobj;
17860 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17861 int result;
17862 PyObject * obj0 = 0 ;
17863 char *kwnames[] = {
17864 (char *) "self", NULL
17865 };
17866
17867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
17868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17869 if (SWIG_arg_fail(1)) SWIG_fail;
17870 {
17871 PyThreadState* __tstate = wxPyBeginAllowThreads();
17872 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
17873
17874 wxPyEndAllowThreads(__tstate);
17875 if (PyErr_Occurred()) SWIG_fail;
17876 }
17877 {
17878 resultobj = SWIG_From_int((int)(result));
17879 }
17880 return resultobj;
17881 fail:
17882 return NULL;
17883 }
17884
17885
17886 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
17887 PyObject *resultobj;
17888 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17889 unsigned int result;
17890 PyObject * obj0 = 0 ;
17891 char *kwnames[] = {
17892 (char *) "self", NULL
17893 };
17894
17895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
17896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17897 if (SWIG_arg_fail(1)) SWIG_fail;
17898 {
17899 PyThreadState* __tstate = wxPyBeginAllowThreads();
17900 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
17901
17902 wxPyEndAllowThreads(__tstate);
17903 if (PyErr_Occurred()) SWIG_fail;
17904 }
17905 {
17906 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
17907 }
17908 return resultobj;
17909 fail:
17910 return NULL;
17911 }
17912
17913
17914 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
17915 PyObject *resultobj;
17916 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17917 unsigned int result;
17918 PyObject * obj0 = 0 ;
17919 char *kwnames[] = {
17920 (char *) "self", NULL
17921 };
17922
17923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
17924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17925 if (SWIG_arg_fail(1)) SWIG_fail;
17926 {
17927 PyThreadState* __tstate = wxPyBeginAllowThreads();
17928 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
17929
17930 wxPyEndAllowThreads(__tstate);
17931 if (PyErr_Occurred()) SWIG_fail;
17932 }
17933 {
17934 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
17935 }
17936 return resultobj;
17937 fail:
17938 return NULL;
17939 }
17940
17941
17942 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17943 PyObject *resultobj;
17944 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17945 wxPoint result;
17946 PyObject * obj0 = 0 ;
17947 char *kwnames[] = {
17948 (char *) "self", NULL
17949 };
17950
17951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
17952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17953 if (SWIG_arg_fail(1)) SWIG_fail;
17954 {
17955 PyThreadState* __tstate = wxPyBeginAllowThreads();
17956 result = (arg1)->GetPosition();
17957
17958 wxPyEndAllowThreads(__tstate);
17959 if (PyErr_Occurred()) SWIG_fail;
17960 }
17961 {
17962 wxPoint * resultptr;
17963 resultptr = new wxPoint((wxPoint &)(result));
17964 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17965 }
17966 return resultobj;
17967 fail:
17968 return NULL;
17969 }
17970
17971
17972 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17973 PyObject *resultobj;
17974 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17975 long *arg2 = (long *) 0 ;
17976 long *arg3 = (long *) 0 ;
17977 long temp2 ;
17978 int res2 = 0 ;
17979 long temp3 ;
17980 int res3 = 0 ;
17981 PyObject * obj0 = 0 ;
17982 char *kwnames[] = {
17983 (char *) "self", NULL
17984 };
17985
17986 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17987 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17990 if (SWIG_arg_fail(1)) SWIG_fail;
17991 {
17992 PyThreadState* __tstate = wxPyBeginAllowThreads();
17993 (arg1)->GetPosition(arg2,arg3);
17994
17995 wxPyEndAllowThreads(__tstate);
17996 if (PyErr_Occurred()) SWIG_fail;
17997 }
17998 Py_INCREF(Py_None); resultobj = Py_None;
17999 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18000 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18001 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18002 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18003 return resultobj;
18004 fail:
18005 return NULL;
18006 }
18007
18008
18009 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18010 PyObject *resultobj;
18011 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18012 int result;
18013 PyObject * obj0 = 0 ;
18014 char *kwnames[] = {
18015 (char *) "self", NULL
18016 };
18017
18018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18020 if (SWIG_arg_fail(1)) SWIG_fail;
18021 {
18022 PyThreadState* __tstate = wxPyBeginAllowThreads();
18023 result = (int)((wxKeyEvent const *)arg1)->GetX();
18024
18025 wxPyEndAllowThreads(__tstate);
18026 if (PyErr_Occurred()) SWIG_fail;
18027 }
18028 {
18029 resultobj = SWIG_From_int((int)(result));
18030 }
18031 return resultobj;
18032 fail:
18033 return NULL;
18034 }
18035
18036
18037 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18038 PyObject *resultobj;
18039 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18040 int result;
18041 PyObject * obj0 = 0 ;
18042 char *kwnames[] = {
18043 (char *) "self", NULL
18044 };
18045
18046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18048 if (SWIG_arg_fail(1)) SWIG_fail;
18049 {
18050 PyThreadState* __tstate = wxPyBeginAllowThreads();
18051 result = (int)((wxKeyEvent const *)arg1)->GetY();
18052
18053 wxPyEndAllowThreads(__tstate);
18054 if (PyErr_Occurred()) SWIG_fail;
18055 }
18056 {
18057 resultobj = SWIG_From_int((int)(result));
18058 }
18059 return resultobj;
18060 fail:
18061 return NULL;
18062 }
18063
18064
18065 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18066 PyObject *resultobj;
18067 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18068 int arg2 ;
18069 PyObject * obj0 = 0 ;
18070 PyObject * obj1 = 0 ;
18071 char *kwnames[] = {
18072 (char *) "self",(char *) "m_x", NULL
18073 };
18074
18075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18077 if (SWIG_arg_fail(1)) SWIG_fail;
18078 {
18079 arg2 = (int)(SWIG_As_int(obj1));
18080 if (SWIG_arg_fail(2)) SWIG_fail;
18081 }
18082 if (arg1) (arg1)->m_x = arg2;
18083
18084 Py_INCREF(Py_None); resultobj = Py_None;
18085 return resultobj;
18086 fail:
18087 return NULL;
18088 }
18089
18090
18091 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18092 PyObject *resultobj;
18093 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18094 int result;
18095 PyObject * obj0 = 0 ;
18096 char *kwnames[] = {
18097 (char *) "self", NULL
18098 };
18099
18100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18102 if (SWIG_arg_fail(1)) SWIG_fail;
18103 result = (int) ((arg1)->m_x);
18104
18105 {
18106 resultobj = SWIG_From_int((int)(result));
18107 }
18108 return resultobj;
18109 fail:
18110 return NULL;
18111 }
18112
18113
18114 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18115 PyObject *resultobj;
18116 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18117 int arg2 ;
18118 PyObject * obj0 = 0 ;
18119 PyObject * obj1 = 0 ;
18120 char *kwnames[] = {
18121 (char *) "self",(char *) "m_y", NULL
18122 };
18123
18124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18126 if (SWIG_arg_fail(1)) SWIG_fail;
18127 {
18128 arg2 = (int)(SWIG_As_int(obj1));
18129 if (SWIG_arg_fail(2)) SWIG_fail;
18130 }
18131 if (arg1) (arg1)->m_y = arg2;
18132
18133 Py_INCREF(Py_None); resultobj = Py_None;
18134 return resultobj;
18135 fail:
18136 return NULL;
18137 }
18138
18139
18140 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18141 PyObject *resultobj;
18142 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18143 int result;
18144 PyObject * obj0 = 0 ;
18145 char *kwnames[] = {
18146 (char *) "self", NULL
18147 };
18148
18149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18151 if (SWIG_arg_fail(1)) SWIG_fail;
18152 result = (int) ((arg1)->m_y);
18153
18154 {
18155 resultobj = SWIG_From_int((int)(result));
18156 }
18157 return resultobj;
18158 fail:
18159 return NULL;
18160 }
18161
18162
18163 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18164 PyObject *resultobj;
18165 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18166 long arg2 ;
18167 PyObject * obj0 = 0 ;
18168 PyObject * obj1 = 0 ;
18169 char *kwnames[] = {
18170 (char *) "self",(char *) "m_keyCode", NULL
18171 };
18172
18173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18175 if (SWIG_arg_fail(1)) SWIG_fail;
18176 {
18177 arg2 = (long)(SWIG_As_long(obj1));
18178 if (SWIG_arg_fail(2)) SWIG_fail;
18179 }
18180 if (arg1) (arg1)->m_keyCode = arg2;
18181
18182 Py_INCREF(Py_None); resultobj = Py_None;
18183 return resultobj;
18184 fail:
18185 return NULL;
18186 }
18187
18188
18189 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18190 PyObject *resultobj;
18191 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18192 long result;
18193 PyObject * obj0 = 0 ;
18194 char *kwnames[] = {
18195 (char *) "self", NULL
18196 };
18197
18198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18200 if (SWIG_arg_fail(1)) SWIG_fail;
18201 result = (long) ((arg1)->m_keyCode);
18202
18203 {
18204 resultobj = SWIG_From_long((long)(result));
18205 }
18206 return resultobj;
18207 fail:
18208 return NULL;
18209 }
18210
18211
18212 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18213 PyObject *resultobj;
18214 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18215 bool arg2 ;
18216 PyObject * obj0 = 0 ;
18217 PyObject * obj1 = 0 ;
18218 char *kwnames[] = {
18219 (char *) "self",(char *) "m_controlDown", NULL
18220 };
18221
18222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18224 if (SWIG_arg_fail(1)) SWIG_fail;
18225 {
18226 arg2 = (bool)(SWIG_As_bool(obj1));
18227 if (SWIG_arg_fail(2)) SWIG_fail;
18228 }
18229 if (arg1) (arg1)->m_controlDown = arg2;
18230
18231 Py_INCREF(Py_None); resultobj = Py_None;
18232 return resultobj;
18233 fail:
18234 return NULL;
18235 }
18236
18237
18238 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18239 PyObject *resultobj;
18240 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18241 bool result;
18242 PyObject * obj0 = 0 ;
18243 char *kwnames[] = {
18244 (char *) "self", NULL
18245 };
18246
18247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18249 if (SWIG_arg_fail(1)) SWIG_fail;
18250 result = (bool) ((arg1)->m_controlDown);
18251
18252 {
18253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18254 }
18255 return resultobj;
18256 fail:
18257 return NULL;
18258 }
18259
18260
18261 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18262 PyObject *resultobj;
18263 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18264 bool arg2 ;
18265 PyObject * obj0 = 0 ;
18266 PyObject * obj1 = 0 ;
18267 char *kwnames[] = {
18268 (char *) "self",(char *) "m_shiftDown", NULL
18269 };
18270
18271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18273 if (SWIG_arg_fail(1)) SWIG_fail;
18274 {
18275 arg2 = (bool)(SWIG_As_bool(obj1));
18276 if (SWIG_arg_fail(2)) SWIG_fail;
18277 }
18278 if (arg1) (arg1)->m_shiftDown = arg2;
18279
18280 Py_INCREF(Py_None); resultobj = Py_None;
18281 return resultobj;
18282 fail:
18283 return NULL;
18284 }
18285
18286
18287 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18288 PyObject *resultobj;
18289 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18290 bool result;
18291 PyObject * obj0 = 0 ;
18292 char *kwnames[] = {
18293 (char *) "self", NULL
18294 };
18295
18296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18298 if (SWIG_arg_fail(1)) SWIG_fail;
18299 result = (bool) ((arg1)->m_shiftDown);
18300
18301 {
18302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18303 }
18304 return resultobj;
18305 fail:
18306 return NULL;
18307 }
18308
18309
18310 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18311 PyObject *resultobj;
18312 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18313 bool arg2 ;
18314 PyObject * obj0 = 0 ;
18315 PyObject * obj1 = 0 ;
18316 char *kwnames[] = {
18317 (char *) "self",(char *) "m_altDown", NULL
18318 };
18319
18320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18322 if (SWIG_arg_fail(1)) SWIG_fail;
18323 {
18324 arg2 = (bool)(SWIG_As_bool(obj1));
18325 if (SWIG_arg_fail(2)) SWIG_fail;
18326 }
18327 if (arg1) (arg1)->m_altDown = arg2;
18328
18329 Py_INCREF(Py_None); resultobj = Py_None;
18330 return resultobj;
18331 fail:
18332 return NULL;
18333 }
18334
18335
18336 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18337 PyObject *resultobj;
18338 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18339 bool result;
18340 PyObject * obj0 = 0 ;
18341 char *kwnames[] = {
18342 (char *) "self", NULL
18343 };
18344
18345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18347 if (SWIG_arg_fail(1)) SWIG_fail;
18348 result = (bool) ((arg1)->m_altDown);
18349
18350 {
18351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18352 }
18353 return resultobj;
18354 fail:
18355 return NULL;
18356 }
18357
18358
18359 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18360 PyObject *resultobj;
18361 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18362 bool arg2 ;
18363 PyObject * obj0 = 0 ;
18364 PyObject * obj1 = 0 ;
18365 char *kwnames[] = {
18366 (char *) "self",(char *) "m_metaDown", NULL
18367 };
18368
18369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18371 if (SWIG_arg_fail(1)) SWIG_fail;
18372 {
18373 arg2 = (bool)(SWIG_As_bool(obj1));
18374 if (SWIG_arg_fail(2)) SWIG_fail;
18375 }
18376 if (arg1) (arg1)->m_metaDown = arg2;
18377
18378 Py_INCREF(Py_None); resultobj = Py_None;
18379 return resultobj;
18380 fail:
18381 return NULL;
18382 }
18383
18384
18385 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18386 PyObject *resultobj;
18387 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18388 bool result;
18389 PyObject * obj0 = 0 ;
18390 char *kwnames[] = {
18391 (char *) "self", NULL
18392 };
18393
18394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18396 if (SWIG_arg_fail(1)) SWIG_fail;
18397 result = (bool) ((arg1)->m_metaDown);
18398
18399 {
18400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18401 }
18402 return resultobj;
18403 fail:
18404 return NULL;
18405 }
18406
18407
18408 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18409 PyObject *resultobj;
18410 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18411 bool arg2 ;
18412 PyObject * obj0 = 0 ;
18413 PyObject * obj1 = 0 ;
18414 char *kwnames[] = {
18415 (char *) "self",(char *) "m_scanCode", NULL
18416 };
18417
18418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18420 if (SWIG_arg_fail(1)) SWIG_fail;
18421 {
18422 arg2 = (bool)(SWIG_As_bool(obj1));
18423 if (SWIG_arg_fail(2)) SWIG_fail;
18424 }
18425 if (arg1) (arg1)->m_scanCode = arg2;
18426
18427 Py_INCREF(Py_None); resultobj = Py_None;
18428 return resultobj;
18429 fail:
18430 return NULL;
18431 }
18432
18433
18434 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18435 PyObject *resultobj;
18436 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18437 bool result;
18438 PyObject * obj0 = 0 ;
18439 char *kwnames[] = {
18440 (char *) "self", NULL
18441 };
18442
18443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18445 if (SWIG_arg_fail(1)) SWIG_fail;
18446 result = (bool) ((arg1)->m_scanCode);
18447
18448 {
18449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18450 }
18451 return resultobj;
18452 fail:
18453 return NULL;
18454 }
18455
18456
18457 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18458 PyObject *resultobj;
18459 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18460 unsigned int arg2 ;
18461 PyObject * obj0 = 0 ;
18462 PyObject * obj1 = 0 ;
18463 char *kwnames[] = {
18464 (char *) "self",(char *) "m_rawCode", NULL
18465 };
18466
18467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18469 if (SWIG_arg_fail(1)) SWIG_fail;
18470 {
18471 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18472 if (SWIG_arg_fail(2)) SWIG_fail;
18473 }
18474 if (arg1) (arg1)->m_rawCode = arg2;
18475
18476 Py_INCREF(Py_None); resultobj = Py_None;
18477 return resultobj;
18478 fail:
18479 return NULL;
18480 }
18481
18482
18483 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18484 PyObject *resultobj;
18485 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18486 unsigned int result;
18487 PyObject * obj0 = 0 ;
18488 char *kwnames[] = {
18489 (char *) "self", NULL
18490 };
18491
18492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18494 if (SWIG_arg_fail(1)) SWIG_fail;
18495 result = (unsigned int) ((arg1)->m_rawCode);
18496
18497 {
18498 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18499 }
18500 return resultobj;
18501 fail:
18502 return NULL;
18503 }
18504
18505
18506 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18507 PyObject *resultobj;
18508 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18509 unsigned int arg2 ;
18510 PyObject * obj0 = 0 ;
18511 PyObject * obj1 = 0 ;
18512 char *kwnames[] = {
18513 (char *) "self",(char *) "m_rawFlags", NULL
18514 };
18515
18516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18518 if (SWIG_arg_fail(1)) SWIG_fail;
18519 {
18520 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18521 if (SWIG_arg_fail(2)) SWIG_fail;
18522 }
18523 if (arg1) (arg1)->m_rawFlags = arg2;
18524
18525 Py_INCREF(Py_None); resultobj = Py_None;
18526 return resultobj;
18527 fail:
18528 return NULL;
18529 }
18530
18531
18532 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
18533 PyObject *resultobj;
18534 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18535 unsigned int result;
18536 PyObject * obj0 = 0 ;
18537 char *kwnames[] = {
18538 (char *) "self", NULL
18539 };
18540
18541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
18542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18543 if (SWIG_arg_fail(1)) SWIG_fail;
18544 result = (unsigned int) ((arg1)->m_rawFlags);
18545
18546 {
18547 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18548 }
18549 return resultobj;
18550 fail:
18551 return NULL;
18552 }
18553
18554
18555 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
18556 PyObject *obj;
18557 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18558 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
18559 Py_INCREF(obj);
18560 return Py_BuildValue((char *)"");
18561 }
18562 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18563 PyObject *resultobj;
18564 wxSize const &arg1_defvalue = wxDefaultSize ;
18565 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
18566 int arg2 = (int) 0 ;
18567 wxSizeEvent *result;
18568 wxSize temp1 ;
18569 PyObject * obj0 = 0 ;
18570 PyObject * obj1 = 0 ;
18571 char *kwnames[] = {
18572 (char *) "sz",(char *) "winid", NULL
18573 };
18574
18575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
18576 if (obj0) {
18577 {
18578 arg1 = &temp1;
18579 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
18580 }
18581 }
18582 if (obj1) {
18583 {
18584 arg2 = (int)(SWIG_As_int(obj1));
18585 if (SWIG_arg_fail(2)) SWIG_fail;
18586 }
18587 }
18588 {
18589 PyThreadState* __tstate = wxPyBeginAllowThreads();
18590 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
18591
18592 wxPyEndAllowThreads(__tstate);
18593 if (PyErr_Occurred()) SWIG_fail;
18594 }
18595 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
18596 return resultobj;
18597 fail:
18598 return NULL;
18599 }
18600
18601
18602 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18603 PyObject *resultobj;
18604 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18605 wxSize result;
18606 PyObject * obj0 = 0 ;
18607 char *kwnames[] = {
18608 (char *) "self", NULL
18609 };
18610
18611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
18612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18613 if (SWIG_arg_fail(1)) SWIG_fail;
18614 {
18615 PyThreadState* __tstate = wxPyBeginAllowThreads();
18616 result = ((wxSizeEvent const *)arg1)->GetSize();
18617
18618 wxPyEndAllowThreads(__tstate);
18619 if (PyErr_Occurred()) SWIG_fail;
18620 }
18621 {
18622 wxSize * resultptr;
18623 resultptr = new wxSize((wxSize &)(result));
18624 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18625 }
18626 return resultobj;
18627 fail:
18628 return NULL;
18629 }
18630
18631
18632 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18633 PyObject *resultobj;
18634 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18635 wxRect result;
18636 PyObject * obj0 = 0 ;
18637 char *kwnames[] = {
18638 (char *) "self", NULL
18639 };
18640
18641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
18642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18643 if (SWIG_arg_fail(1)) SWIG_fail;
18644 {
18645 PyThreadState* __tstate = wxPyBeginAllowThreads();
18646 result = ((wxSizeEvent const *)arg1)->GetRect();
18647
18648 wxPyEndAllowThreads(__tstate);
18649 if (PyErr_Occurred()) SWIG_fail;
18650 }
18651 {
18652 wxRect * resultptr;
18653 resultptr = new wxRect((wxRect &)(result));
18654 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18655 }
18656 return resultobj;
18657 fail:
18658 return NULL;
18659 }
18660
18661
18662 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18663 PyObject *resultobj;
18664 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18665 wxRect arg2 ;
18666 PyObject * obj0 = 0 ;
18667 PyObject * obj1 = 0 ;
18668 char *kwnames[] = {
18669 (char *) "self",(char *) "rect", NULL
18670 };
18671
18672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18674 if (SWIG_arg_fail(1)) SWIG_fail;
18675 {
18676 wxRect * argp;
18677 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18678 if (SWIG_arg_fail(2)) SWIG_fail;
18679 if (argp == NULL) {
18680 SWIG_null_ref("wxRect");
18681 }
18682 if (SWIG_arg_fail(2)) SWIG_fail;
18683 arg2 = *argp;
18684 }
18685 {
18686 PyThreadState* __tstate = wxPyBeginAllowThreads();
18687 (arg1)->SetRect(arg2);
18688
18689 wxPyEndAllowThreads(__tstate);
18690 if (PyErr_Occurred()) SWIG_fail;
18691 }
18692 Py_INCREF(Py_None); resultobj = Py_None;
18693 return resultobj;
18694 fail:
18695 return NULL;
18696 }
18697
18698
18699 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18700 PyObject *resultobj;
18701 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18702 wxSize arg2 ;
18703 PyObject * obj0 = 0 ;
18704 PyObject * obj1 = 0 ;
18705 char *kwnames[] = {
18706 (char *) "self",(char *) "size", NULL
18707 };
18708
18709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
18710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18711 if (SWIG_arg_fail(1)) SWIG_fail;
18712 {
18713 wxSize * argp;
18714 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
18715 if (SWIG_arg_fail(2)) SWIG_fail;
18716 if (argp == NULL) {
18717 SWIG_null_ref("wxSize");
18718 }
18719 if (SWIG_arg_fail(2)) SWIG_fail;
18720 arg2 = *argp;
18721 }
18722 {
18723 PyThreadState* __tstate = wxPyBeginAllowThreads();
18724 wxSizeEvent_SetSize(arg1,arg2);
18725
18726 wxPyEndAllowThreads(__tstate);
18727 if (PyErr_Occurred()) SWIG_fail;
18728 }
18729 Py_INCREF(Py_None); resultobj = Py_None;
18730 return resultobj;
18731 fail:
18732 return NULL;
18733 }
18734
18735
18736 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
18737 PyObject *resultobj;
18738 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18739 wxSize *arg2 = (wxSize *) 0 ;
18740 PyObject * obj0 = 0 ;
18741 PyObject * obj1 = 0 ;
18742 char *kwnames[] = {
18743 (char *) "self",(char *) "m_size", NULL
18744 };
18745
18746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
18747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18748 if (SWIG_arg_fail(1)) SWIG_fail;
18749 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
18750 if (SWIG_arg_fail(2)) SWIG_fail;
18751 if (arg1) (arg1)->m_size = *arg2;
18752
18753 Py_INCREF(Py_None); resultobj = Py_None;
18754 return resultobj;
18755 fail:
18756 return NULL;
18757 }
18758
18759
18760 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
18761 PyObject *resultobj;
18762 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18763 wxSize *result;
18764 PyObject * obj0 = 0 ;
18765 char *kwnames[] = {
18766 (char *) "self", NULL
18767 };
18768
18769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
18770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18771 if (SWIG_arg_fail(1)) SWIG_fail;
18772 result = (wxSize *)& ((arg1)->m_size);
18773
18774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
18775 return resultobj;
18776 fail:
18777 return NULL;
18778 }
18779
18780
18781 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
18782 PyObject *resultobj;
18783 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18784 wxRect *arg2 = (wxRect *) 0 ;
18785 PyObject * obj0 = 0 ;
18786 PyObject * obj1 = 0 ;
18787 char *kwnames[] = {
18788 (char *) "self",(char *) "m_rect", NULL
18789 };
18790
18791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
18792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18793 if (SWIG_arg_fail(1)) SWIG_fail;
18794 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18795 if (SWIG_arg_fail(2)) SWIG_fail;
18796 if (arg1) (arg1)->m_rect = *arg2;
18797
18798 Py_INCREF(Py_None); resultobj = Py_None;
18799 return resultobj;
18800 fail:
18801 return NULL;
18802 }
18803
18804
18805 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
18806 PyObject *resultobj;
18807 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18808 wxRect *result;
18809 PyObject * obj0 = 0 ;
18810 char *kwnames[] = {
18811 (char *) "self", NULL
18812 };
18813
18814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
18815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18816 if (SWIG_arg_fail(1)) SWIG_fail;
18817 result = (wxRect *)& ((arg1)->m_rect);
18818
18819 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
18820 return resultobj;
18821 fail:
18822 return NULL;
18823 }
18824
18825
18826 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
18827 PyObject *obj;
18828 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18829 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
18830 Py_INCREF(obj);
18831 return Py_BuildValue((char *)"");
18832 }
18833 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18834 PyObject *resultobj;
18835 wxPoint const &arg1_defvalue = wxDefaultPosition ;
18836 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
18837 int arg2 = (int) 0 ;
18838 wxMoveEvent *result;
18839 wxPoint temp1 ;
18840 PyObject * obj0 = 0 ;
18841 PyObject * obj1 = 0 ;
18842 char *kwnames[] = {
18843 (char *) "pos",(char *) "winid", NULL
18844 };
18845
18846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
18847 if (obj0) {
18848 {
18849 arg1 = &temp1;
18850 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
18851 }
18852 }
18853 if (obj1) {
18854 {
18855 arg2 = (int)(SWIG_As_int(obj1));
18856 if (SWIG_arg_fail(2)) SWIG_fail;
18857 }
18858 }
18859 {
18860 PyThreadState* __tstate = wxPyBeginAllowThreads();
18861 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
18862
18863 wxPyEndAllowThreads(__tstate);
18864 if (PyErr_Occurred()) SWIG_fail;
18865 }
18866 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
18867 return resultobj;
18868 fail:
18869 return NULL;
18870 }
18871
18872
18873 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18874 PyObject *resultobj;
18875 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18876 wxPoint result;
18877 PyObject * obj0 = 0 ;
18878 char *kwnames[] = {
18879 (char *) "self", NULL
18880 };
18881
18882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
18883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18884 if (SWIG_arg_fail(1)) SWIG_fail;
18885 {
18886 PyThreadState* __tstate = wxPyBeginAllowThreads();
18887 result = ((wxMoveEvent const *)arg1)->GetPosition();
18888
18889 wxPyEndAllowThreads(__tstate);
18890 if (PyErr_Occurred()) SWIG_fail;
18891 }
18892 {
18893 wxPoint * resultptr;
18894 resultptr = new wxPoint((wxPoint &)(result));
18895 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18896 }
18897 return resultobj;
18898 fail:
18899 return NULL;
18900 }
18901
18902
18903 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18904 PyObject *resultobj;
18905 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18906 wxRect result;
18907 PyObject * obj0 = 0 ;
18908 char *kwnames[] = {
18909 (char *) "self", NULL
18910 };
18911
18912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
18913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18914 if (SWIG_arg_fail(1)) SWIG_fail;
18915 {
18916 PyThreadState* __tstate = wxPyBeginAllowThreads();
18917 result = ((wxMoveEvent const *)arg1)->GetRect();
18918
18919 wxPyEndAllowThreads(__tstate);
18920 if (PyErr_Occurred()) SWIG_fail;
18921 }
18922 {
18923 wxRect * resultptr;
18924 resultptr = new wxRect((wxRect &)(result));
18925 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18926 }
18927 return resultobj;
18928 fail:
18929 return NULL;
18930 }
18931
18932
18933 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18934 PyObject *resultobj;
18935 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18936 wxRect *arg2 = 0 ;
18937 wxRect temp2 ;
18938 PyObject * obj0 = 0 ;
18939 PyObject * obj1 = 0 ;
18940 char *kwnames[] = {
18941 (char *) "self",(char *) "rect", NULL
18942 };
18943
18944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18946 if (SWIG_arg_fail(1)) SWIG_fail;
18947 {
18948 arg2 = &temp2;
18949 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18950 }
18951 {
18952 PyThreadState* __tstate = wxPyBeginAllowThreads();
18953 (arg1)->SetRect((wxRect const &)*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 = 0 ;
18969 wxPoint temp2 ;
18970 PyObject * obj0 = 0 ;
18971 PyObject * obj1 = 0 ;
18972 char *kwnames[] = {
18973 (char *) "self",(char *) "pos", NULL
18974 };
18975
18976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
18977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18978 if (SWIG_arg_fail(1)) SWIG_fail;
18979 {
18980 arg2 = &temp2;
18981 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
18982 }
18983 {
18984 PyThreadState* __tstate = wxPyBeginAllowThreads();
18985 (arg1)->SetPosition((wxPoint const &)*arg2);
18986
18987 wxPyEndAllowThreads(__tstate);
18988 if (PyErr_Occurred()) SWIG_fail;
18989 }
18990 Py_INCREF(Py_None); resultobj = Py_None;
18991 return resultobj;
18992 fail:
18993 return NULL;
18994 }
18995
18996
18997 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
18998 PyObject *obj;
18999 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19000 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19001 Py_INCREF(obj);
19002 return Py_BuildValue((char *)"");
19003 }
19004 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19005 PyObject *resultobj;
19006 int arg1 = (int) 0 ;
19007 wxPaintEvent *result;
19008 PyObject * obj0 = 0 ;
19009 char *kwnames[] = {
19010 (char *) "Id", NULL
19011 };
19012
19013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19014 if (obj0) {
19015 {
19016 arg1 = (int)(SWIG_As_int(obj0));
19017 if (SWIG_arg_fail(1)) SWIG_fail;
19018 }
19019 }
19020 {
19021 PyThreadState* __tstate = wxPyBeginAllowThreads();
19022 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19023
19024 wxPyEndAllowThreads(__tstate);
19025 if (PyErr_Occurred()) SWIG_fail;
19026 }
19027 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19028 return resultobj;
19029 fail:
19030 return NULL;
19031 }
19032
19033
19034 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19035 PyObject *obj;
19036 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19037 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19038 Py_INCREF(obj);
19039 return Py_BuildValue((char *)"");
19040 }
19041 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19042 PyObject *resultobj;
19043 int arg1 = (int) 0 ;
19044 wxNcPaintEvent *result;
19045 PyObject * obj0 = 0 ;
19046 char *kwnames[] = {
19047 (char *) "winid", NULL
19048 };
19049
19050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19051 if (obj0) {
19052 {
19053 arg1 = (int)(SWIG_As_int(obj0));
19054 if (SWIG_arg_fail(1)) SWIG_fail;
19055 }
19056 }
19057 {
19058 PyThreadState* __tstate = wxPyBeginAllowThreads();
19059 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19060
19061 wxPyEndAllowThreads(__tstate);
19062 if (PyErr_Occurred()) SWIG_fail;
19063 }
19064 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19065 return resultobj;
19066 fail:
19067 return NULL;
19068 }
19069
19070
19071 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19072 PyObject *obj;
19073 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19074 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19075 Py_INCREF(obj);
19076 return Py_BuildValue((char *)"");
19077 }
19078 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19079 PyObject *resultobj;
19080 int arg1 = (int) 0 ;
19081 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19082 wxEraseEvent *result;
19083 PyObject * obj0 = 0 ;
19084 PyObject * obj1 = 0 ;
19085 char *kwnames[] = {
19086 (char *) "Id",(char *) "dc", NULL
19087 };
19088
19089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19090 if (obj0) {
19091 {
19092 arg1 = (int)(SWIG_As_int(obj0));
19093 if (SWIG_arg_fail(1)) SWIG_fail;
19094 }
19095 }
19096 if (obj1) {
19097 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19098 if (SWIG_arg_fail(2)) SWIG_fail;
19099 }
19100 {
19101 PyThreadState* __tstate = wxPyBeginAllowThreads();
19102 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19103
19104 wxPyEndAllowThreads(__tstate);
19105 if (PyErr_Occurred()) SWIG_fail;
19106 }
19107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19108 return resultobj;
19109 fail:
19110 return NULL;
19111 }
19112
19113
19114 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19115 PyObject *resultobj;
19116 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19117 wxDC *result;
19118 PyObject * obj0 = 0 ;
19119 char *kwnames[] = {
19120 (char *) "self", NULL
19121 };
19122
19123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19125 if (SWIG_arg_fail(1)) SWIG_fail;
19126 {
19127 PyThreadState* __tstate = wxPyBeginAllowThreads();
19128 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19129
19130 wxPyEndAllowThreads(__tstate);
19131 if (PyErr_Occurred()) SWIG_fail;
19132 }
19133 {
19134 resultobj = wxPyMake_wxObject(result, 0);
19135 }
19136 return resultobj;
19137 fail:
19138 return NULL;
19139 }
19140
19141
19142 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19143 PyObject *obj;
19144 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19145 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19146 Py_INCREF(obj);
19147 return Py_BuildValue((char *)"");
19148 }
19149 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19150 PyObject *resultobj;
19151 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19152 int arg2 = (int) 0 ;
19153 wxFocusEvent *result;
19154 PyObject * obj0 = 0 ;
19155 PyObject * obj1 = 0 ;
19156 char *kwnames[] = {
19157 (char *) "type",(char *) "winid", NULL
19158 };
19159
19160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19161 if (obj0) {
19162 {
19163 arg1 = (wxEventType)(SWIG_As_int(obj0));
19164 if (SWIG_arg_fail(1)) SWIG_fail;
19165 }
19166 }
19167 if (obj1) {
19168 {
19169 arg2 = (int)(SWIG_As_int(obj1));
19170 if (SWIG_arg_fail(2)) SWIG_fail;
19171 }
19172 }
19173 {
19174 PyThreadState* __tstate = wxPyBeginAllowThreads();
19175 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19176
19177 wxPyEndAllowThreads(__tstate);
19178 if (PyErr_Occurred()) SWIG_fail;
19179 }
19180 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19181 return resultobj;
19182 fail:
19183 return NULL;
19184 }
19185
19186
19187 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19188 PyObject *resultobj;
19189 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19190 wxWindow *result;
19191 PyObject * obj0 = 0 ;
19192 char *kwnames[] = {
19193 (char *) "self", NULL
19194 };
19195
19196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19198 if (SWIG_arg_fail(1)) SWIG_fail;
19199 {
19200 PyThreadState* __tstate = wxPyBeginAllowThreads();
19201 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19202
19203 wxPyEndAllowThreads(__tstate);
19204 if (PyErr_Occurred()) SWIG_fail;
19205 }
19206 {
19207 resultobj = wxPyMake_wxObject(result, 0);
19208 }
19209 return resultobj;
19210 fail:
19211 return NULL;
19212 }
19213
19214
19215 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19216 PyObject *resultobj;
19217 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19218 wxWindow *arg2 = (wxWindow *) 0 ;
19219 PyObject * obj0 = 0 ;
19220 PyObject * obj1 = 0 ;
19221 char *kwnames[] = {
19222 (char *) "self",(char *) "win", NULL
19223 };
19224
19225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19227 if (SWIG_arg_fail(1)) SWIG_fail;
19228 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19229 if (SWIG_arg_fail(2)) SWIG_fail;
19230 {
19231 PyThreadState* __tstate = wxPyBeginAllowThreads();
19232 (arg1)->SetWindow(arg2);
19233
19234 wxPyEndAllowThreads(__tstate);
19235 if (PyErr_Occurred()) SWIG_fail;
19236 }
19237 Py_INCREF(Py_None); resultobj = Py_None;
19238 return resultobj;
19239 fail:
19240 return NULL;
19241 }
19242
19243
19244 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19245 PyObject *obj;
19246 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19247 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19248 Py_INCREF(obj);
19249 return Py_BuildValue((char *)"");
19250 }
19251 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19252 PyObject *resultobj;
19253 wxWindow *arg1 = (wxWindow *) NULL ;
19254 wxChildFocusEvent *result;
19255 PyObject * obj0 = 0 ;
19256 char *kwnames[] = {
19257 (char *) "win", NULL
19258 };
19259
19260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19261 if (obj0) {
19262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19263 if (SWIG_arg_fail(1)) SWIG_fail;
19264 }
19265 {
19266 PyThreadState* __tstate = wxPyBeginAllowThreads();
19267 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19268
19269 wxPyEndAllowThreads(__tstate);
19270 if (PyErr_Occurred()) SWIG_fail;
19271 }
19272 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19273 return resultobj;
19274 fail:
19275 return NULL;
19276 }
19277
19278
19279 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19280 PyObject *resultobj;
19281 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19282 wxWindow *result;
19283 PyObject * obj0 = 0 ;
19284 char *kwnames[] = {
19285 (char *) "self", NULL
19286 };
19287
19288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19290 if (SWIG_arg_fail(1)) SWIG_fail;
19291 {
19292 PyThreadState* __tstate = wxPyBeginAllowThreads();
19293 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19294
19295 wxPyEndAllowThreads(__tstate);
19296 if (PyErr_Occurred()) SWIG_fail;
19297 }
19298 {
19299 resultobj = wxPyMake_wxObject(result, 0);
19300 }
19301 return resultobj;
19302 fail:
19303 return NULL;
19304 }
19305
19306
19307 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19308 PyObject *obj;
19309 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19310 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19311 Py_INCREF(obj);
19312 return Py_BuildValue((char *)"");
19313 }
19314 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19315 PyObject *resultobj;
19316 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19317 bool arg2 = (bool) true ;
19318 int arg3 = (int) 0 ;
19319 wxActivateEvent *result;
19320 PyObject * obj0 = 0 ;
19321 PyObject * obj1 = 0 ;
19322 PyObject * obj2 = 0 ;
19323 char *kwnames[] = {
19324 (char *) "type",(char *) "active",(char *) "Id", NULL
19325 };
19326
19327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19328 if (obj0) {
19329 {
19330 arg1 = (wxEventType)(SWIG_As_int(obj0));
19331 if (SWIG_arg_fail(1)) SWIG_fail;
19332 }
19333 }
19334 if (obj1) {
19335 {
19336 arg2 = (bool)(SWIG_As_bool(obj1));
19337 if (SWIG_arg_fail(2)) SWIG_fail;
19338 }
19339 }
19340 if (obj2) {
19341 {
19342 arg3 = (int)(SWIG_As_int(obj2));
19343 if (SWIG_arg_fail(3)) SWIG_fail;
19344 }
19345 }
19346 {
19347 PyThreadState* __tstate = wxPyBeginAllowThreads();
19348 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19349
19350 wxPyEndAllowThreads(__tstate);
19351 if (PyErr_Occurred()) SWIG_fail;
19352 }
19353 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19354 return resultobj;
19355 fail:
19356 return NULL;
19357 }
19358
19359
19360 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19361 PyObject *resultobj;
19362 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19363 bool result;
19364 PyObject * obj0 = 0 ;
19365 char *kwnames[] = {
19366 (char *) "self", NULL
19367 };
19368
19369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19371 if (SWIG_arg_fail(1)) SWIG_fail;
19372 {
19373 PyThreadState* __tstate = wxPyBeginAllowThreads();
19374 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19375
19376 wxPyEndAllowThreads(__tstate);
19377 if (PyErr_Occurred()) SWIG_fail;
19378 }
19379 {
19380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19381 }
19382 return resultobj;
19383 fail:
19384 return NULL;
19385 }
19386
19387
19388 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19389 PyObject *obj;
19390 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19391 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19392 Py_INCREF(obj);
19393 return Py_BuildValue((char *)"");
19394 }
19395 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19396 PyObject *resultobj;
19397 int arg1 = (int) 0 ;
19398 wxInitDialogEvent *result;
19399 PyObject * obj0 = 0 ;
19400 char *kwnames[] = {
19401 (char *) "Id", NULL
19402 };
19403
19404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19405 if (obj0) {
19406 {
19407 arg1 = (int)(SWIG_As_int(obj0));
19408 if (SWIG_arg_fail(1)) SWIG_fail;
19409 }
19410 }
19411 {
19412 PyThreadState* __tstate = wxPyBeginAllowThreads();
19413 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19414
19415 wxPyEndAllowThreads(__tstate);
19416 if (PyErr_Occurred()) SWIG_fail;
19417 }
19418 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19419 return resultobj;
19420 fail:
19421 return NULL;
19422 }
19423
19424
19425 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19426 PyObject *obj;
19427 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19428 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19429 Py_INCREF(obj);
19430 return Py_BuildValue((char *)"");
19431 }
19432 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19433 PyObject *resultobj;
19434 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19435 int arg2 = (int) 0 ;
19436 wxMenu *arg3 = (wxMenu *) NULL ;
19437 wxMenuEvent *result;
19438 PyObject * obj0 = 0 ;
19439 PyObject * obj1 = 0 ;
19440 PyObject * obj2 = 0 ;
19441 char *kwnames[] = {
19442 (char *) "type",(char *) "winid",(char *) "menu", NULL
19443 };
19444
19445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19446 if (obj0) {
19447 {
19448 arg1 = (wxEventType)(SWIG_As_int(obj0));
19449 if (SWIG_arg_fail(1)) SWIG_fail;
19450 }
19451 }
19452 if (obj1) {
19453 {
19454 arg2 = (int)(SWIG_As_int(obj1));
19455 if (SWIG_arg_fail(2)) SWIG_fail;
19456 }
19457 }
19458 if (obj2) {
19459 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19460 if (SWIG_arg_fail(3)) SWIG_fail;
19461 }
19462 {
19463 PyThreadState* __tstate = wxPyBeginAllowThreads();
19464 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19465
19466 wxPyEndAllowThreads(__tstate);
19467 if (PyErr_Occurred()) SWIG_fail;
19468 }
19469 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19470 return resultobj;
19471 fail:
19472 return NULL;
19473 }
19474
19475
19476 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19477 PyObject *resultobj;
19478 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19479 int result;
19480 PyObject * obj0 = 0 ;
19481 char *kwnames[] = {
19482 (char *) "self", NULL
19483 };
19484
19485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19487 if (SWIG_arg_fail(1)) SWIG_fail;
19488 {
19489 PyThreadState* __tstate = wxPyBeginAllowThreads();
19490 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19491
19492 wxPyEndAllowThreads(__tstate);
19493 if (PyErr_Occurred()) SWIG_fail;
19494 }
19495 {
19496 resultobj = SWIG_From_int((int)(result));
19497 }
19498 return resultobj;
19499 fail:
19500 return NULL;
19501 }
19502
19503
19504 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19505 PyObject *resultobj;
19506 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19507 bool result;
19508 PyObject * obj0 = 0 ;
19509 char *kwnames[] = {
19510 (char *) "self", NULL
19511 };
19512
19513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19515 if (SWIG_arg_fail(1)) SWIG_fail;
19516 {
19517 PyThreadState* __tstate = wxPyBeginAllowThreads();
19518 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19519
19520 wxPyEndAllowThreads(__tstate);
19521 if (PyErr_Occurred()) SWIG_fail;
19522 }
19523 {
19524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19525 }
19526 return resultobj;
19527 fail:
19528 return NULL;
19529 }
19530
19531
19532 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
19533 PyObject *resultobj;
19534 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19535 wxMenu *result;
19536 PyObject * obj0 = 0 ;
19537 char *kwnames[] = {
19538 (char *) "self", NULL
19539 };
19540
19541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
19542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19543 if (SWIG_arg_fail(1)) SWIG_fail;
19544 {
19545 PyThreadState* __tstate = wxPyBeginAllowThreads();
19546 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
19547
19548 wxPyEndAllowThreads(__tstate);
19549 if (PyErr_Occurred()) SWIG_fail;
19550 }
19551 {
19552 resultobj = wxPyMake_wxObject(result, 0);
19553 }
19554 return resultobj;
19555 fail:
19556 return NULL;
19557 }
19558
19559
19560 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
19561 PyObject *obj;
19562 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19563 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
19564 Py_INCREF(obj);
19565 return Py_BuildValue((char *)"");
19566 }
19567 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19568 PyObject *resultobj;
19569 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19570 int arg2 = (int) 0 ;
19571 wxCloseEvent *result;
19572 PyObject * obj0 = 0 ;
19573 PyObject * obj1 = 0 ;
19574 char *kwnames[] = {
19575 (char *) "type",(char *) "winid", NULL
19576 };
19577
19578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
19579 if (obj0) {
19580 {
19581 arg1 = (wxEventType)(SWIG_As_int(obj0));
19582 if (SWIG_arg_fail(1)) SWIG_fail;
19583 }
19584 }
19585 if (obj1) {
19586 {
19587 arg2 = (int)(SWIG_As_int(obj1));
19588 if (SWIG_arg_fail(2)) SWIG_fail;
19589 }
19590 }
19591 {
19592 PyThreadState* __tstate = wxPyBeginAllowThreads();
19593 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
19594
19595 wxPyEndAllowThreads(__tstate);
19596 if (PyErr_Occurred()) SWIG_fail;
19597 }
19598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
19599 return resultobj;
19600 fail:
19601 return NULL;
19602 }
19603
19604
19605 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19606 PyObject *resultobj;
19607 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19608 bool arg2 ;
19609 PyObject * obj0 = 0 ;
19610 PyObject * obj1 = 0 ;
19611 char *kwnames[] = {
19612 (char *) "self",(char *) "logOff", NULL
19613 };
19614
19615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
19616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19617 if (SWIG_arg_fail(1)) SWIG_fail;
19618 {
19619 arg2 = (bool)(SWIG_As_bool(obj1));
19620 if (SWIG_arg_fail(2)) SWIG_fail;
19621 }
19622 {
19623 PyThreadState* __tstate = wxPyBeginAllowThreads();
19624 (arg1)->SetLoggingOff(arg2);
19625
19626 wxPyEndAllowThreads(__tstate);
19627 if (PyErr_Occurred()) SWIG_fail;
19628 }
19629 Py_INCREF(Py_None); resultobj = Py_None;
19630 return resultobj;
19631 fail:
19632 return NULL;
19633 }
19634
19635
19636 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19637 PyObject *resultobj;
19638 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19639 bool result;
19640 PyObject * obj0 = 0 ;
19641 char *kwnames[] = {
19642 (char *) "self", NULL
19643 };
19644
19645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
19646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19647 if (SWIG_arg_fail(1)) SWIG_fail;
19648 {
19649 PyThreadState* __tstate = wxPyBeginAllowThreads();
19650 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
19651
19652 wxPyEndAllowThreads(__tstate);
19653 if (PyErr_Occurred()) SWIG_fail;
19654 }
19655 {
19656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19657 }
19658 return resultobj;
19659 fail:
19660 return NULL;
19661 }
19662
19663
19664 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
19665 PyObject *resultobj;
19666 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19667 bool arg2 = (bool) true ;
19668 PyObject * obj0 = 0 ;
19669 PyObject * obj1 = 0 ;
19670 char *kwnames[] = {
19671 (char *) "self",(char *) "veto", NULL
19672 };
19673
19674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
19675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19676 if (SWIG_arg_fail(1)) SWIG_fail;
19677 if (obj1) {
19678 {
19679 arg2 = (bool)(SWIG_As_bool(obj1));
19680 if (SWIG_arg_fail(2)) SWIG_fail;
19681 }
19682 }
19683 {
19684 PyThreadState* __tstate = wxPyBeginAllowThreads();
19685 (arg1)->Veto(arg2);
19686
19687 wxPyEndAllowThreads(__tstate);
19688 if (PyErr_Occurred()) SWIG_fail;
19689 }
19690 Py_INCREF(Py_None); resultobj = Py_None;
19691 return resultobj;
19692 fail:
19693 return NULL;
19694 }
19695
19696
19697 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19698 PyObject *resultobj;
19699 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19700 bool arg2 ;
19701 PyObject * obj0 = 0 ;
19702 PyObject * obj1 = 0 ;
19703 char *kwnames[] = {
19704 (char *) "self",(char *) "canVeto", NULL
19705 };
19706
19707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
19708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19709 if (SWIG_arg_fail(1)) SWIG_fail;
19710 {
19711 arg2 = (bool)(SWIG_As_bool(obj1));
19712 if (SWIG_arg_fail(2)) SWIG_fail;
19713 }
19714 {
19715 PyThreadState* __tstate = wxPyBeginAllowThreads();
19716 (arg1)->SetCanVeto(arg2);
19717
19718 wxPyEndAllowThreads(__tstate);
19719 if (PyErr_Occurred()) SWIG_fail;
19720 }
19721 Py_INCREF(Py_None); resultobj = Py_None;
19722 return resultobj;
19723 fail:
19724 return NULL;
19725 }
19726
19727
19728 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19729 PyObject *resultobj;
19730 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19731 bool result;
19732 PyObject * obj0 = 0 ;
19733 char *kwnames[] = {
19734 (char *) "self", NULL
19735 };
19736
19737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
19738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19739 if (SWIG_arg_fail(1)) SWIG_fail;
19740 {
19741 PyThreadState* __tstate = wxPyBeginAllowThreads();
19742 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
19743
19744 wxPyEndAllowThreads(__tstate);
19745 if (PyErr_Occurred()) SWIG_fail;
19746 }
19747 {
19748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19749 }
19750 return resultobj;
19751 fail:
19752 return NULL;
19753 }
19754
19755
19756 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19757 PyObject *resultobj;
19758 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19759 bool result;
19760 PyObject * obj0 = 0 ;
19761 char *kwnames[] = {
19762 (char *) "self", NULL
19763 };
19764
19765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
19766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19767 if (SWIG_arg_fail(1)) SWIG_fail;
19768 {
19769 PyThreadState* __tstate = wxPyBeginAllowThreads();
19770 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
19771
19772 wxPyEndAllowThreads(__tstate);
19773 if (PyErr_Occurred()) SWIG_fail;
19774 }
19775 {
19776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19777 }
19778 return resultobj;
19779 fail:
19780 return NULL;
19781 }
19782
19783
19784 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
19785 PyObject *obj;
19786 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19787 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
19788 Py_INCREF(obj);
19789 return Py_BuildValue((char *)"");
19790 }
19791 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19792 PyObject *resultobj;
19793 int arg1 = (int) 0 ;
19794 bool arg2 = (bool) false ;
19795 wxShowEvent *result;
19796 PyObject * obj0 = 0 ;
19797 PyObject * obj1 = 0 ;
19798 char *kwnames[] = {
19799 (char *) "winid",(char *) "show", NULL
19800 };
19801
19802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
19803 if (obj0) {
19804 {
19805 arg1 = (int)(SWIG_As_int(obj0));
19806 if (SWIG_arg_fail(1)) SWIG_fail;
19807 }
19808 }
19809 if (obj1) {
19810 {
19811 arg2 = (bool)(SWIG_As_bool(obj1));
19812 if (SWIG_arg_fail(2)) SWIG_fail;
19813 }
19814 }
19815 {
19816 PyThreadState* __tstate = wxPyBeginAllowThreads();
19817 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
19818
19819 wxPyEndAllowThreads(__tstate);
19820 if (PyErr_Occurred()) SWIG_fail;
19821 }
19822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
19823 return resultobj;
19824 fail:
19825 return NULL;
19826 }
19827
19828
19829 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
19830 PyObject *resultobj;
19831 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
19832 bool arg2 ;
19833 PyObject * obj0 = 0 ;
19834 PyObject * obj1 = 0 ;
19835 char *kwnames[] = {
19836 (char *) "self",(char *) "show", NULL
19837 };
19838
19839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
19840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
19841 if (SWIG_arg_fail(1)) SWIG_fail;
19842 {
19843 arg2 = (bool)(SWIG_As_bool(obj1));
19844 if (SWIG_arg_fail(2)) SWIG_fail;
19845 }
19846 {
19847 PyThreadState* __tstate = wxPyBeginAllowThreads();
19848 (arg1)->SetShow(arg2);
19849
19850 wxPyEndAllowThreads(__tstate);
19851 if (PyErr_Occurred()) SWIG_fail;
19852 }
19853 Py_INCREF(Py_None); resultobj = Py_None;
19854 return resultobj;
19855 fail:
19856 return NULL;
19857 }
19858
19859
19860 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
19861 PyObject *resultobj;
19862 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
19863 bool result;
19864 PyObject * obj0 = 0 ;
19865 char *kwnames[] = {
19866 (char *) "self", NULL
19867 };
19868
19869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
19870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
19871 if (SWIG_arg_fail(1)) SWIG_fail;
19872 {
19873 PyThreadState* __tstate = wxPyBeginAllowThreads();
19874 result = (bool)((wxShowEvent const *)arg1)->GetShow();
19875
19876 wxPyEndAllowThreads(__tstate);
19877 if (PyErr_Occurred()) SWIG_fail;
19878 }
19879 {
19880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19881 }
19882 return resultobj;
19883 fail:
19884 return NULL;
19885 }
19886
19887
19888 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
19889 PyObject *obj;
19890 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19891 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
19892 Py_INCREF(obj);
19893 return Py_BuildValue((char *)"");
19894 }
19895 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19896 PyObject *resultobj;
19897 int arg1 = (int) 0 ;
19898 bool arg2 = (bool) true ;
19899 wxIconizeEvent *result;
19900 PyObject * obj0 = 0 ;
19901 PyObject * obj1 = 0 ;
19902 char *kwnames[] = {
19903 (char *) "id",(char *) "iconized", NULL
19904 };
19905
19906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
19907 if (obj0) {
19908 {
19909 arg1 = (int)(SWIG_As_int(obj0));
19910 if (SWIG_arg_fail(1)) SWIG_fail;
19911 }
19912 }
19913 if (obj1) {
19914 {
19915 arg2 = (bool)(SWIG_As_bool(obj1));
19916 if (SWIG_arg_fail(2)) SWIG_fail;
19917 }
19918 }
19919 {
19920 PyThreadState* __tstate = wxPyBeginAllowThreads();
19921 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
19922
19923 wxPyEndAllowThreads(__tstate);
19924 if (PyErr_Occurred()) SWIG_fail;
19925 }
19926 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
19927 return resultobj;
19928 fail:
19929 return NULL;
19930 }
19931
19932
19933 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
19934 PyObject *resultobj;
19935 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
19936 bool result;
19937 PyObject * obj0 = 0 ;
19938 char *kwnames[] = {
19939 (char *) "self", NULL
19940 };
19941
19942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
19943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
19944 if (SWIG_arg_fail(1)) SWIG_fail;
19945 {
19946 PyThreadState* __tstate = wxPyBeginAllowThreads();
19947 result = (bool)(arg1)->Iconized();
19948
19949 wxPyEndAllowThreads(__tstate);
19950 if (PyErr_Occurred()) SWIG_fail;
19951 }
19952 {
19953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19954 }
19955 return resultobj;
19956 fail:
19957 return NULL;
19958 }
19959
19960
19961 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
19962 PyObject *obj;
19963 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19964 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
19965 Py_INCREF(obj);
19966 return Py_BuildValue((char *)"");
19967 }
19968 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19969 PyObject *resultobj;
19970 int arg1 = (int) 0 ;
19971 wxMaximizeEvent *result;
19972 PyObject * obj0 = 0 ;
19973 char *kwnames[] = {
19974 (char *) "id", NULL
19975 };
19976
19977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
19978 if (obj0) {
19979 {
19980 arg1 = (int)(SWIG_As_int(obj0));
19981 if (SWIG_arg_fail(1)) SWIG_fail;
19982 }
19983 }
19984 {
19985 PyThreadState* __tstate = wxPyBeginAllowThreads();
19986 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
19987
19988 wxPyEndAllowThreads(__tstate);
19989 if (PyErr_Occurred()) SWIG_fail;
19990 }
19991 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
19992 return resultobj;
19993 fail:
19994 return NULL;
19995 }
19996
19997
19998 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
19999 PyObject *obj;
20000 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20001 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20002 Py_INCREF(obj);
20003 return Py_BuildValue((char *)"");
20004 }
20005 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20006 PyObject *resultobj;
20007 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20008 wxPoint result;
20009 PyObject * obj0 = 0 ;
20010 char *kwnames[] = {
20011 (char *) "self", NULL
20012 };
20013
20014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20016 if (SWIG_arg_fail(1)) SWIG_fail;
20017 {
20018 PyThreadState* __tstate = wxPyBeginAllowThreads();
20019 result = (arg1)->GetPosition();
20020
20021 wxPyEndAllowThreads(__tstate);
20022 if (PyErr_Occurred()) SWIG_fail;
20023 }
20024 {
20025 wxPoint * resultptr;
20026 resultptr = new wxPoint((wxPoint &)(result));
20027 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20028 }
20029 return resultobj;
20030 fail:
20031 return NULL;
20032 }
20033
20034
20035 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20036 PyObject *resultobj;
20037 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20038 int result;
20039 PyObject * obj0 = 0 ;
20040 char *kwnames[] = {
20041 (char *) "self", NULL
20042 };
20043
20044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20046 if (SWIG_arg_fail(1)) SWIG_fail;
20047 {
20048 PyThreadState* __tstate = wxPyBeginAllowThreads();
20049 result = (int)(arg1)->GetNumberOfFiles();
20050
20051 wxPyEndAllowThreads(__tstate);
20052 if (PyErr_Occurred()) SWIG_fail;
20053 }
20054 {
20055 resultobj = SWIG_From_int((int)(result));
20056 }
20057 return resultobj;
20058 fail:
20059 return NULL;
20060 }
20061
20062
20063 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20064 PyObject *resultobj;
20065 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20066 PyObject *result;
20067 PyObject * obj0 = 0 ;
20068 char *kwnames[] = {
20069 (char *) "self", NULL
20070 };
20071
20072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20074 if (SWIG_arg_fail(1)) SWIG_fail;
20075 {
20076 PyThreadState* __tstate = wxPyBeginAllowThreads();
20077 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20078
20079 wxPyEndAllowThreads(__tstate);
20080 if (PyErr_Occurred()) SWIG_fail;
20081 }
20082 resultobj = result;
20083 return resultobj;
20084 fail:
20085 return NULL;
20086 }
20087
20088
20089 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20090 PyObject *obj;
20091 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20092 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20093 Py_INCREF(obj);
20094 return Py_BuildValue((char *)"");
20095 }
20096 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20097 PyObject *resultobj;
20098 int arg1 = (int) 0 ;
20099 wxUpdateUIEvent *result;
20100 PyObject * obj0 = 0 ;
20101 char *kwnames[] = {
20102 (char *) "commandId", NULL
20103 };
20104
20105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20106 if (obj0) {
20107 {
20108 arg1 = (int)(SWIG_As_int(obj0));
20109 if (SWIG_arg_fail(1)) SWIG_fail;
20110 }
20111 }
20112 {
20113 PyThreadState* __tstate = wxPyBeginAllowThreads();
20114 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20115
20116 wxPyEndAllowThreads(__tstate);
20117 if (PyErr_Occurred()) SWIG_fail;
20118 }
20119 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20120 return resultobj;
20121 fail:
20122 return NULL;
20123 }
20124
20125
20126 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20127 PyObject *resultobj;
20128 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20129 bool result;
20130 PyObject * obj0 = 0 ;
20131 char *kwnames[] = {
20132 (char *) "self", NULL
20133 };
20134
20135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20137 if (SWIG_arg_fail(1)) SWIG_fail;
20138 {
20139 PyThreadState* __tstate = wxPyBeginAllowThreads();
20140 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20141
20142 wxPyEndAllowThreads(__tstate);
20143 if (PyErr_Occurred()) SWIG_fail;
20144 }
20145 {
20146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20147 }
20148 return resultobj;
20149 fail:
20150 return NULL;
20151 }
20152
20153
20154 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20155 PyObject *resultobj;
20156 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20157 bool result;
20158 PyObject * obj0 = 0 ;
20159 char *kwnames[] = {
20160 (char *) "self", NULL
20161 };
20162
20163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20165 if (SWIG_arg_fail(1)) SWIG_fail;
20166 {
20167 PyThreadState* __tstate = wxPyBeginAllowThreads();
20168 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20169
20170 wxPyEndAllowThreads(__tstate);
20171 if (PyErr_Occurred()) SWIG_fail;
20172 }
20173 {
20174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20175 }
20176 return resultobj;
20177 fail:
20178 return NULL;
20179 }
20180
20181
20182 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20183 PyObject *resultobj;
20184 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20185 wxString result;
20186 PyObject * obj0 = 0 ;
20187 char *kwnames[] = {
20188 (char *) "self", NULL
20189 };
20190
20191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20193 if (SWIG_arg_fail(1)) SWIG_fail;
20194 {
20195 PyThreadState* __tstate = wxPyBeginAllowThreads();
20196 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20197
20198 wxPyEndAllowThreads(__tstate);
20199 if (PyErr_Occurred()) SWIG_fail;
20200 }
20201 {
20202 #if wxUSE_UNICODE
20203 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20204 #else
20205 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20206 #endif
20207 }
20208 return resultobj;
20209 fail:
20210 return NULL;
20211 }
20212
20213
20214 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20215 PyObject *resultobj;
20216 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20217 bool result;
20218 PyObject * obj0 = 0 ;
20219 char *kwnames[] = {
20220 (char *) "self", NULL
20221 };
20222
20223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20225 if (SWIG_arg_fail(1)) SWIG_fail;
20226 {
20227 PyThreadState* __tstate = wxPyBeginAllowThreads();
20228 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20229
20230 wxPyEndAllowThreads(__tstate);
20231 if (PyErr_Occurred()) SWIG_fail;
20232 }
20233 {
20234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20235 }
20236 return resultobj;
20237 fail:
20238 return NULL;
20239 }
20240
20241
20242 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20243 PyObject *resultobj;
20244 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20245 bool result;
20246 PyObject * obj0 = 0 ;
20247 char *kwnames[] = {
20248 (char *) "self", NULL
20249 };
20250
20251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20253 if (SWIG_arg_fail(1)) SWIG_fail;
20254 {
20255 PyThreadState* __tstate = wxPyBeginAllowThreads();
20256 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20257
20258 wxPyEndAllowThreads(__tstate);
20259 if (PyErr_Occurred()) SWIG_fail;
20260 }
20261 {
20262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20263 }
20264 return resultobj;
20265 fail:
20266 return NULL;
20267 }
20268
20269
20270 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20271 PyObject *resultobj;
20272 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20273 bool result;
20274 PyObject * obj0 = 0 ;
20275 char *kwnames[] = {
20276 (char *) "self", NULL
20277 };
20278
20279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20281 if (SWIG_arg_fail(1)) SWIG_fail;
20282 {
20283 PyThreadState* __tstate = wxPyBeginAllowThreads();
20284 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20285
20286 wxPyEndAllowThreads(__tstate);
20287 if (PyErr_Occurred()) SWIG_fail;
20288 }
20289 {
20290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20291 }
20292 return resultobj;
20293 fail:
20294 return NULL;
20295 }
20296
20297
20298 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20299 PyObject *resultobj;
20300 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20301 bool arg2 ;
20302 PyObject * obj0 = 0 ;
20303 PyObject * obj1 = 0 ;
20304 char *kwnames[] = {
20305 (char *) "self",(char *) "check", NULL
20306 };
20307
20308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20310 if (SWIG_arg_fail(1)) SWIG_fail;
20311 {
20312 arg2 = (bool)(SWIG_As_bool(obj1));
20313 if (SWIG_arg_fail(2)) SWIG_fail;
20314 }
20315 {
20316 PyThreadState* __tstate = wxPyBeginAllowThreads();
20317 (arg1)->Check(arg2);
20318
20319 wxPyEndAllowThreads(__tstate);
20320 if (PyErr_Occurred()) SWIG_fail;
20321 }
20322 Py_INCREF(Py_None); resultobj = Py_None;
20323 return resultobj;
20324 fail:
20325 return NULL;
20326 }
20327
20328
20329 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20330 PyObject *resultobj;
20331 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20332 bool arg2 ;
20333 PyObject * obj0 = 0 ;
20334 PyObject * obj1 = 0 ;
20335 char *kwnames[] = {
20336 (char *) "self",(char *) "enable", NULL
20337 };
20338
20339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20341 if (SWIG_arg_fail(1)) SWIG_fail;
20342 {
20343 arg2 = (bool)(SWIG_As_bool(obj1));
20344 if (SWIG_arg_fail(2)) SWIG_fail;
20345 }
20346 {
20347 PyThreadState* __tstate = wxPyBeginAllowThreads();
20348 (arg1)->Enable(arg2);
20349
20350 wxPyEndAllowThreads(__tstate);
20351 if (PyErr_Occurred()) SWIG_fail;
20352 }
20353 Py_INCREF(Py_None); resultobj = Py_None;
20354 return resultobj;
20355 fail:
20356 return NULL;
20357 }
20358
20359
20360 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20361 PyObject *resultobj;
20362 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20363 wxString *arg2 = 0 ;
20364 bool temp2 = false ;
20365 PyObject * obj0 = 0 ;
20366 PyObject * obj1 = 0 ;
20367 char *kwnames[] = {
20368 (char *) "self",(char *) "text", NULL
20369 };
20370
20371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20373 if (SWIG_arg_fail(1)) SWIG_fail;
20374 {
20375 arg2 = wxString_in_helper(obj1);
20376 if (arg2 == NULL) SWIG_fail;
20377 temp2 = true;
20378 }
20379 {
20380 PyThreadState* __tstate = wxPyBeginAllowThreads();
20381 (arg1)->SetText((wxString const &)*arg2);
20382
20383 wxPyEndAllowThreads(__tstate);
20384 if (PyErr_Occurred()) SWIG_fail;
20385 }
20386 Py_INCREF(Py_None); resultobj = Py_None;
20387 {
20388 if (temp2)
20389 delete arg2;
20390 }
20391 return resultobj;
20392 fail:
20393 {
20394 if (temp2)
20395 delete arg2;
20396 }
20397 return NULL;
20398 }
20399
20400
20401 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20402 PyObject *resultobj;
20403 long arg1 ;
20404 PyObject * obj0 = 0 ;
20405 char *kwnames[] = {
20406 (char *) "updateInterval", NULL
20407 };
20408
20409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20410 {
20411 arg1 = (long)(SWIG_As_long(obj0));
20412 if (SWIG_arg_fail(1)) SWIG_fail;
20413 }
20414 {
20415 PyThreadState* __tstate = wxPyBeginAllowThreads();
20416 wxUpdateUIEvent::SetUpdateInterval(arg1);
20417
20418 wxPyEndAllowThreads(__tstate);
20419 if (PyErr_Occurred()) SWIG_fail;
20420 }
20421 Py_INCREF(Py_None); resultobj = Py_None;
20422 return resultobj;
20423 fail:
20424 return NULL;
20425 }
20426
20427
20428 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20429 PyObject *resultobj;
20430 long result;
20431 char *kwnames[] = {
20432 NULL
20433 };
20434
20435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20436 {
20437 PyThreadState* __tstate = wxPyBeginAllowThreads();
20438 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20439
20440 wxPyEndAllowThreads(__tstate);
20441 if (PyErr_Occurred()) SWIG_fail;
20442 }
20443 {
20444 resultobj = SWIG_From_long((long)(result));
20445 }
20446 return resultobj;
20447 fail:
20448 return NULL;
20449 }
20450
20451
20452 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20453 PyObject *resultobj;
20454 wxWindow *arg1 = (wxWindow *) 0 ;
20455 bool result;
20456 PyObject * obj0 = 0 ;
20457 char *kwnames[] = {
20458 (char *) "win", NULL
20459 };
20460
20461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20463 if (SWIG_arg_fail(1)) SWIG_fail;
20464 {
20465 PyThreadState* __tstate = wxPyBeginAllowThreads();
20466 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20467
20468 wxPyEndAllowThreads(__tstate);
20469 if (PyErr_Occurred()) SWIG_fail;
20470 }
20471 {
20472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20473 }
20474 return resultobj;
20475 fail:
20476 return NULL;
20477 }
20478
20479
20480 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20481 PyObject *resultobj;
20482 char *kwnames[] = {
20483 NULL
20484 };
20485
20486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20487 {
20488 PyThreadState* __tstate = wxPyBeginAllowThreads();
20489 wxUpdateUIEvent::ResetUpdateTime();
20490
20491 wxPyEndAllowThreads(__tstate);
20492 if (PyErr_Occurred()) SWIG_fail;
20493 }
20494 Py_INCREF(Py_None); resultobj = Py_None;
20495 return resultobj;
20496 fail:
20497 return NULL;
20498 }
20499
20500
20501 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20502 PyObject *resultobj;
20503 wxUpdateUIMode arg1 ;
20504 PyObject * obj0 = 0 ;
20505 char *kwnames[] = {
20506 (char *) "mode", NULL
20507 };
20508
20509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20510 {
20511 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20512 if (SWIG_arg_fail(1)) SWIG_fail;
20513 }
20514 {
20515 PyThreadState* __tstate = wxPyBeginAllowThreads();
20516 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20517
20518 wxPyEndAllowThreads(__tstate);
20519 if (PyErr_Occurred()) SWIG_fail;
20520 }
20521 Py_INCREF(Py_None); resultobj = Py_None;
20522 return resultobj;
20523 fail:
20524 return NULL;
20525 }
20526
20527
20528 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20529 PyObject *resultobj;
20530 wxUpdateUIMode result;
20531 char *kwnames[] = {
20532 NULL
20533 };
20534
20535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
20536 {
20537 PyThreadState* __tstate = wxPyBeginAllowThreads();
20538 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
20539
20540 wxPyEndAllowThreads(__tstate);
20541 if (PyErr_Occurred()) SWIG_fail;
20542 }
20543 resultobj = SWIG_From_int((result));
20544 return resultobj;
20545 fail:
20546 return NULL;
20547 }
20548
20549
20550 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
20551 PyObject *obj;
20552 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20553 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
20554 Py_INCREF(obj);
20555 return Py_BuildValue((char *)"");
20556 }
20557 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20558 PyObject *resultobj;
20559 wxSysColourChangedEvent *result;
20560 char *kwnames[] = {
20561 NULL
20562 };
20563
20564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
20565 {
20566 PyThreadState* __tstate = wxPyBeginAllowThreads();
20567 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
20568
20569 wxPyEndAllowThreads(__tstate);
20570 if (PyErr_Occurred()) SWIG_fail;
20571 }
20572 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
20573 return resultobj;
20574 fail:
20575 return NULL;
20576 }
20577
20578
20579 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
20580 PyObject *obj;
20581 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20582 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
20583 Py_INCREF(obj);
20584 return Py_BuildValue((char *)"");
20585 }
20586 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20587 PyObject *resultobj;
20588 int arg1 = (int) 0 ;
20589 wxWindow *arg2 = (wxWindow *) NULL ;
20590 wxMouseCaptureChangedEvent *result;
20591 PyObject * obj0 = 0 ;
20592 PyObject * obj1 = 0 ;
20593 char *kwnames[] = {
20594 (char *) "winid",(char *) "gainedCapture", NULL
20595 };
20596
20597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
20598 if (obj0) {
20599 {
20600 arg1 = (int)(SWIG_As_int(obj0));
20601 if (SWIG_arg_fail(1)) SWIG_fail;
20602 }
20603 }
20604 if (obj1) {
20605 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20606 if (SWIG_arg_fail(2)) SWIG_fail;
20607 }
20608 {
20609 PyThreadState* __tstate = wxPyBeginAllowThreads();
20610 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
20611
20612 wxPyEndAllowThreads(__tstate);
20613 if (PyErr_Occurred()) SWIG_fail;
20614 }
20615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
20616 return resultobj;
20617 fail:
20618 return NULL;
20619 }
20620
20621
20622 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20623 PyObject *resultobj;
20624 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
20625 wxWindow *result;
20626 PyObject * obj0 = 0 ;
20627 char *kwnames[] = {
20628 (char *) "self", NULL
20629 };
20630
20631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
20632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20633 if (SWIG_arg_fail(1)) SWIG_fail;
20634 {
20635 PyThreadState* __tstate = wxPyBeginAllowThreads();
20636 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
20637
20638 wxPyEndAllowThreads(__tstate);
20639 if (PyErr_Occurred()) SWIG_fail;
20640 }
20641 {
20642 resultobj = wxPyMake_wxObject(result, 0);
20643 }
20644 return resultobj;
20645 fail:
20646 return NULL;
20647 }
20648
20649
20650 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
20651 PyObject *obj;
20652 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20653 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
20654 Py_INCREF(obj);
20655 return Py_BuildValue((char *)"");
20656 }
20657 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20658 PyObject *resultobj;
20659 wxDisplayChangedEvent *result;
20660 char *kwnames[] = {
20661 NULL
20662 };
20663
20664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
20665 {
20666 PyThreadState* __tstate = wxPyBeginAllowThreads();
20667 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
20668
20669 wxPyEndAllowThreads(__tstate);
20670 if (PyErr_Occurred()) SWIG_fail;
20671 }
20672 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
20673 return resultobj;
20674 fail:
20675 return NULL;
20676 }
20677
20678
20679 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
20680 PyObject *obj;
20681 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20682 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
20683 Py_INCREF(obj);
20684 return Py_BuildValue((char *)"");
20685 }
20686 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20687 PyObject *resultobj;
20688 int arg1 = (int) 0 ;
20689 wxPaletteChangedEvent *result;
20690 PyObject * obj0 = 0 ;
20691 char *kwnames[] = {
20692 (char *) "id", NULL
20693 };
20694
20695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
20696 if (obj0) {
20697 {
20698 arg1 = (int)(SWIG_As_int(obj0));
20699 if (SWIG_arg_fail(1)) SWIG_fail;
20700 }
20701 }
20702 {
20703 PyThreadState* __tstate = wxPyBeginAllowThreads();
20704 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
20705
20706 wxPyEndAllowThreads(__tstate);
20707 if (PyErr_Occurred()) SWIG_fail;
20708 }
20709 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
20710 return resultobj;
20711 fail:
20712 return NULL;
20713 }
20714
20715
20716 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20717 PyObject *resultobj;
20718 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20719 wxWindow *arg2 = (wxWindow *) 0 ;
20720 PyObject * obj0 = 0 ;
20721 PyObject * obj1 = 0 ;
20722 char *kwnames[] = {
20723 (char *) "self",(char *) "win", NULL
20724 };
20725
20726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
20727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20728 if (SWIG_arg_fail(1)) SWIG_fail;
20729 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20730 if (SWIG_arg_fail(2)) SWIG_fail;
20731 {
20732 PyThreadState* __tstate = wxPyBeginAllowThreads();
20733 (arg1)->SetChangedWindow(arg2);
20734
20735 wxPyEndAllowThreads(__tstate);
20736 if (PyErr_Occurred()) SWIG_fail;
20737 }
20738 Py_INCREF(Py_None); resultobj = Py_None;
20739 return resultobj;
20740 fail:
20741 return NULL;
20742 }
20743
20744
20745 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20746 PyObject *resultobj;
20747 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20748 wxWindow *result;
20749 PyObject * obj0 = 0 ;
20750 char *kwnames[] = {
20751 (char *) "self", NULL
20752 };
20753
20754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
20755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20756 if (SWIG_arg_fail(1)) SWIG_fail;
20757 {
20758 PyThreadState* __tstate = wxPyBeginAllowThreads();
20759 result = (wxWindow *)(arg1)->GetChangedWindow();
20760
20761 wxPyEndAllowThreads(__tstate);
20762 if (PyErr_Occurred()) SWIG_fail;
20763 }
20764 {
20765 resultobj = wxPyMake_wxObject(result, 0);
20766 }
20767 return resultobj;
20768 fail:
20769 return NULL;
20770 }
20771
20772
20773 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
20774 PyObject *obj;
20775 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20776 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
20777 Py_INCREF(obj);
20778 return Py_BuildValue((char *)"");
20779 }
20780 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20781 PyObject *resultobj;
20782 int arg1 = (int) 0 ;
20783 wxQueryNewPaletteEvent *result;
20784 PyObject * obj0 = 0 ;
20785 char *kwnames[] = {
20786 (char *) "winid", NULL
20787 };
20788
20789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
20790 if (obj0) {
20791 {
20792 arg1 = (int)(SWIG_As_int(obj0));
20793 if (SWIG_arg_fail(1)) SWIG_fail;
20794 }
20795 }
20796 {
20797 PyThreadState* __tstate = wxPyBeginAllowThreads();
20798 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
20799
20800 wxPyEndAllowThreads(__tstate);
20801 if (PyErr_Occurred()) SWIG_fail;
20802 }
20803 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
20804 return resultobj;
20805 fail:
20806 return NULL;
20807 }
20808
20809
20810 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20811 PyObject *resultobj;
20812 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20813 bool arg2 ;
20814 PyObject * obj0 = 0 ;
20815 PyObject * obj1 = 0 ;
20816 char *kwnames[] = {
20817 (char *) "self",(char *) "realized", NULL
20818 };
20819
20820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
20821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
20822 if (SWIG_arg_fail(1)) SWIG_fail;
20823 {
20824 arg2 = (bool)(SWIG_As_bool(obj1));
20825 if (SWIG_arg_fail(2)) SWIG_fail;
20826 }
20827 {
20828 PyThreadState* __tstate = wxPyBeginAllowThreads();
20829 (arg1)->SetPaletteRealized(arg2);
20830
20831 wxPyEndAllowThreads(__tstate);
20832 if (PyErr_Occurred()) SWIG_fail;
20833 }
20834 Py_INCREF(Py_None); resultobj = Py_None;
20835 return resultobj;
20836 fail:
20837 return NULL;
20838 }
20839
20840
20841 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20842 PyObject *resultobj;
20843 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20844 bool result;
20845 PyObject * obj0 = 0 ;
20846 char *kwnames[] = {
20847 (char *) "self", NULL
20848 };
20849
20850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
20851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
20852 if (SWIG_arg_fail(1)) SWIG_fail;
20853 {
20854 PyThreadState* __tstate = wxPyBeginAllowThreads();
20855 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
20856
20857 wxPyEndAllowThreads(__tstate);
20858 if (PyErr_Occurred()) SWIG_fail;
20859 }
20860 {
20861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20862 }
20863 return resultobj;
20864 fail:
20865 return NULL;
20866 }
20867
20868
20869 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
20870 PyObject *obj;
20871 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20872 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
20873 Py_INCREF(obj);
20874 return Py_BuildValue((char *)"");
20875 }
20876 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20877 PyObject *resultobj;
20878 wxNavigationKeyEvent *result;
20879 char *kwnames[] = {
20880 NULL
20881 };
20882
20883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
20884 {
20885 PyThreadState* __tstate = wxPyBeginAllowThreads();
20886 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
20887
20888 wxPyEndAllowThreads(__tstate);
20889 if (PyErr_Occurred()) SWIG_fail;
20890 }
20891 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
20892 return resultobj;
20893 fail:
20894 return NULL;
20895 }
20896
20897
20898 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
20899 PyObject *resultobj;
20900 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
20901 bool result;
20902 PyObject * obj0 = 0 ;
20903 char *kwnames[] = {
20904 (char *) "self", NULL
20905 };
20906
20907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
20908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20909 if (SWIG_arg_fail(1)) SWIG_fail;
20910 {
20911 PyThreadState* __tstate = wxPyBeginAllowThreads();
20912 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
20913
20914 wxPyEndAllowThreads(__tstate);
20915 if (PyErr_Occurred()) SWIG_fail;
20916 }
20917 {
20918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20919 }
20920 return resultobj;
20921 fail:
20922 return NULL;
20923 }
20924
20925
20926 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
20927 PyObject *resultobj;
20928 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
20929 bool arg2 ;
20930 PyObject * obj0 = 0 ;
20931 PyObject * obj1 = 0 ;
20932 char *kwnames[] = {
20933 (char *) "self",(char *) "forward", NULL
20934 };
20935
20936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
20937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20938 if (SWIG_arg_fail(1)) SWIG_fail;
20939 {
20940 arg2 = (bool)(SWIG_As_bool(obj1));
20941 if (SWIG_arg_fail(2)) SWIG_fail;
20942 }
20943 {
20944 PyThreadState* __tstate = wxPyBeginAllowThreads();
20945 (arg1)->SetDirection(arg2);
20946
20947 wxPyEndAllowThreads(__tstate);
20948 if (PyErr_Occurred()) SWIG_fail;
20949 }
20950 Py_INCREF(Py_None); resultobj = Py_None;
20951 return resultobj;
20952 fail:
20953 return NULL;
20954 }
20955
20956
20957 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
20958 PyObject *resultobj;
20959 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
20960 bool result;
20961 PyObject * obj0 = 0 ;
20962 char *kwnames[] = {
20963 (char *) "self", NULL
20964 };
20965
20966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
20967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20968 if (SWIG_arg_fail(1)) SWIG_fail;
20969 {
20970 PyThreadState* __tstate = wxPyBeginAllowThreads();
20971 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
20972
20973 wxPyEndAllowThreads(__tstate);
20974 if (PyErr_Occurred()) SWIG_fail;
20975 }
20976 {
20977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20978 }
20979 return resultobj;
20980 fail:
20981 return NULL;
20982 }
20983
20984
20985 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
20986 PyObject *resultobj;
20987 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
20988 bool arg2 ;
20989 PyObject * obj0 = 0 ;
20990 PyObject * obj1 = 0 ;
20991 char *kwnames[] = {
20992 (char *) "self",(char *) "ischange", NULL
20993 };
20994
20995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
20996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20997 if (SWIG_arg_fail(1)) SWIG_fail;
20998 {
20999 arg2 = (bool)(SWIG_As_bool(obj1));
21000 if (SWIG_arg_fail(2)) SWIG_fail;
21001 }
21002 {
21003 PyThreadState* __tstate = wxPyBeginAllowThreads();
21004 (arg1)->SetWindowChange(arg2);
21005
21006 wxPyEndAllowThreads(__tstate);
21007 if (PyErr_Occurred()) SWIG_fail;
21008 }
21009 Py_INCREF(Py_None); resultobj = Py_None;
21010 return resultobj;
21011 fail:
21012 return NULL;
21013 }
21014
21015
21016 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21017 PyObject *resultobj;
21018 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21019 long arg2 ;
21020 PyObject * obj0 = 0 ;
21021 PyObject * obj1 = 0 ;
21022 char *kwnames[] = {
21023 (char *) "self",(char *) "flags", NULL
21024 };
21025
21026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21028 if (SWIG_arg_fail(1)) SWIG_fail;
21029 {
21030 arg2 = (long)(SWIG_As_long(obj1));
21031 if (SWIG_arg_fail(2)) SWIG_fail;
21032 }
21033 {
21034 PyThreadState* __tstate = wxPyBeginAllowThreads();
21035 (arg1)->SetFlags(arg2);
21036
21037 wxPyEndAllowThreads(__tstate);
21038 if (PyErr_Occurred()) SWIG_fail;
21039 }
21040 Py_INCREF(Py_None); resultobj = Py_None;
21041 return resultobj;
21042 fail:
21043 return NULL;
21044 }
21045
21046
21047 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21048 PyObject *resultobj;
21049 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21050 wxWindow *result;
21051 PyObject * obj0 = 0 ;
21052 char *kwnames[] = {
21053 (char *) "self", NULL
21054 };
21055
21056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21058 if (SWIG_arg_fail(1)) SWIG_fail;
21059 {
21060 PyThreadState* __tstate = wxPyBeginAllowThreads();
21061 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21062
21063 wxPyEndAllowThreads(__tstate);
21064 if (PyErr_Occurred()) SWIG_fail;
21065 }
21066 {
21067 resultobj = wxPyMake_wxObject(result, 0);
21068 }
21069 return resultobj;
21070 fail:
21071 return NULL;
21072 }
21073
21074
21075 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21076 PyObject *resultobj;
21077 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21078 wxWindow *arg2 = (wxWindow *) 0 ;
21079 PyObject * obj0 = 0 ;
21080 PyObject * obj1 = 0 ;
21081 char *kwnames[] = {
21082 (char *) "self",(char *) "win", NULL
21083 };
21084
21085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21087 if (SWIG_arg_fail(1)) SWIG_fail;
21088 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21089 if (SWIG_arg_fail(2)) SWIG_fail;
21090 {
21091 PyThreadState* __tstate = wxPyBeginAllowThreads();
21092 (arg1)->SetCurrentFocus(arg2);
21093
21094 wxPyEndAllowThreads(__tstate);
21095 if (PyErr_Occurred()) SWIG_fail;
21096 }
21097 Py_INCREF(Py_None); resultobj = Py_None;
21098 return resultobj;
21099 fail:
21100 return NULL;
21101 }
21102
21103
21104 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21105 PyObject *obj;
21106 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21107 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21108 Py_INCREF(obj);
21109 return Py_BuildValue((char *)"");
21110 }
21111 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21112 PyObject *resultobj;
21113 wxWindow *arg1 = (wxWindow *) NULL ;
21114 wxWindowCreateEvent *result;
21115 PyObject * obj0 = 0 ;
21116 char *kwnames[] = {
21117 (char *) "win", NULL
21118 };
21119
21120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21121 if (obj0) {
21122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21123 if (SWIG_arg_fail(1)) SWIG_fail;
21124 }
21125 {
21126 PyThreadState* __tstate = wxPyBeginAllowThreads();
21127 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21128
21129 wxPyEndAllowThreads(__tstate);
21130 if (PyErr_Occurred()) SWIG_fail;
21131 }
21132 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21133 return resultobj;
21134 fail:
21135 return NULL;
21136 }
21137
21138
21139 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21140 PyObject *resultobj;
21141 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21142 wxWindow *result;
21143 PyObject * obj0 = 0 ;
21144 char *kwnames[] = {
21145 (char *) "self", NULL
21146 };
21147
21148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21150 if (SWIG_arg_fail(1)) SWIG_fail;
21151 {
21152 PyThreadState* __tstate = wxPyBeginAllowThreads();
21153 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21154
21155 wxPyEndAllowThreads(__tstate);
21156 if (PyErr_Occurred()) SWIG_fail;
21157 }
21158 {
21159 resultobj = wxPyMake_wxObject(result, 0);
21160 }
21161 return resultobj;
21162 fail:
21163 return NULL;
21164 }
21165
21166
21167 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21168 PyObject *obj;
21169 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21170 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21171 Py_INCREF(obj);
21172 return Py_BuildValue((char *)"");
21173 }
21174 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21175 PyObject *resultobj;
21176 wxWindow *arg1 = (wxWindow *) NULL ;
21177 wxWindowDestroyEvent *result;
21178 PyObject * obj0 = 0 ;
21179 char *kwnames[] = {
21180 (char *) "win", NULL
21181 };
21182
21183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21184 if (obj0) {
21185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21186 if (SWIG_arg_fail(1)) SWIG_fail;
21187 }
21188 {
21189 PyThreadState* __tstate = wxPyBeginAllowThreads();
21190 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21191
21192 wxPyEndAllowThreads(__tstate);
21193 if (PyErr_Occurred()) SWIG_fail;
21194 }
21195 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21196 return resultobj;
21197 fail:
21198 return NULL;
21199 }
21200
21201
21202 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21203 PyObject *resultobj;
21204 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21205 wxWindow *result;
21206 PyObject * obj0 = 0 ;
21207 char *kwnames[] = {
21208 (char *) "self", NULL
21209 };
21210
21211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21213 if (SWIG_arg_fail(1)) SWIG_fail;
21214 {
21215 PyThreadState* __tstate = wxPyBeginAllowThreads();
21216 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21217
21218 wxPyEndAllowThreads(__tstate);
21219 if (PyErr_Occurred()) SWIG_fail;
21220 }
21221 {
21222 resultobj = wxPyMake_wxObject(result, 0);
21223 }
21224 return resultobj;
21225 fail:
21226 return NULL;
21227 }
21228
21229
21230 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21231 PyObject *obj;
21232 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21233 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21234 Py_INCREF(obj);
21235 return Py_BuildValue((char *)"");
21236 }
21237 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21238 PyObject *resultobj;
21239 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21240 int arg2 = (int) 0 ;
21241 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21242 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21243 wxContextMenuEvent *result;
21244 wxPoint temp3 ;
21245 PyObject * obj0 = 0 ;
21246 PyObject * obj1 = 0 ;
21247 PyObject * obj2 = 0 ;
21248 char *kwnames[] = {
21249 (char *) "type",(char *) "winid",(char *) "pt", NULL
21250 };
21251
21252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21253 if (obj0) {
21254 {
21255 arg1 = (wxEventType)(SWIG_As_int(obj0));
21256 if (SWIG_arg_fail(1)) SWIG_fail;
21257 }
21258 }
21259 if (obj1) {
21260 {
21261 arg2 = (int)(SWIG_As_int(obj1));
21262 if (SWIG_arg_fail(2)) SWIG_fail;
21263 }
21264 }
21265 if (obj2) {
21266 {
21267 arg3 = &temp3;
21268 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21269 }
21270 }
21271 {
21272 PyThreadState* __tstate = wxPyBeginAllowThreads();
21273 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21274
21275 wxPyEndAllowThreads(__tstate);
21276 if (PyErr_Occurred()) SWIG_fail;
21277 }
21278 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21279 return resultobj;
21280 fail:
21281 return NULL;
21282 }
21283
21284
21285 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21286 PyObject *resultobj;
21287 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21288 wxPoint *result;
21289 PyObject * obj0 = 0 ;
21290 char *kwnames[] = {
21291 (char *) "self", NULL
21292 };
21293
21294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21296 if (SWIG_arg_fail(1)) SWIG_fail;
21297 {
21298 PyThreadState* __tstate = wxPyBeginAllowThreads();
21299 {
21300 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21301 result = (wxPoint *) &_result_ref;
21302 }
21303
21304 wxPyEndAllowThreads(__tstate);
21305 if (PyErr_Occurred()) SWIG_fail;
21306 }
21307 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21308 return resultobj;
21309 fail:
21310 return NULL;
21311 }
21312
21313
21314 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21315 PyObject *resultobj;
21316 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21317 wxPoint *arg2 = 0 ;
21318 wxPoint temp2 ;
21319 PyObject * obj0 = 0 ;
21320 PyObject * obj1 = 0 ;
21321 char *kwnames[] = {
21322 (char *) "self",(char *) "pos", NULL
21323 };
21324
21325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21327 if (SWIG_arg_fail(1)) SWIG_fail;
21328 {
21329 arg2 = &temp2;
21330 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21331 }
21332 {
21333 PyThreadState* __tstate = wxPyBeginAllowThreads();
21334 (arg1)->SetPosition((wxPoint const &)*arg2);
21335
21336 wxPyEndAllowThreads(__tstate);
21337 if (PyErr_Occurred()) SWIG_fail;
21338 }
21339 Py_INCREF(Py_None); resultobj = Py_None;
21340 return resultobj;
21341 fail:
21342 return NULL;
21343 }
21344
21345
21346 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21347 PyObject *obj;
21348 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21349 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21350 Py_INCREF(obj);
21351 return Py_BuildValue((char *)"");
21352 }
21353 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21354 PyObject *resultobj;
21355 wxIdleEvent *result;
21356 char *kwnames[] = {
21357 NULL
21358 };
21359
21360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21361 {
21362 PyThreadState* __tstate = wxPyBeginAllowThreads();
21363 result = (wxIdleEvent *)new wxIdleEvent();
21364
21365 wxPyEndAllowThreads(__tstate);
21366 if (PyErr_Occurred()) SWIG_fail;
21367 }
21368 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21369 return resultobj;
21370 fail:
21371 return NULL;
21372 }
21373
21374
21375 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21376 PyObject *resultobj;
21377 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21378 bool arg2 = (bool) true ;
21379 PyObject * obj0 = 0 ;
21380 PyObject * obj1 = 0 ;
21381 char *kwnames[] = {
21382 (char *) "self",(char *) "needMore", NULL
21383 };
21384
21385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21387 if (SWIG_arg_fail(1)) SWIG_fail;
21388 if (obj1) {
21389 {
21390 arg2 = (bool)(SWIG_As_bool(obj1));
21391 if (SWIG_arg_fail(2)) SWIG_fail;
21392 }
21393 }
21394 {
21395 PyThreadState* __tstate = wxPyBeginAllowThreads();
21396 (arg1)->RequestMore(arg2);
21397
21398 wxPyEndAllowThreads(__tstate);
21399 if (PyErr_Occurred()) SWIG_fail;
21400 }
21401 Py_INCREF(Py_None); resultobj = Py_None;
21402 return resultobj;
21403 fail:
21404 return NULL;
21405 }
21406
21407
21408 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21409 PyObject *resultobj;
21410 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21411 bool result;
21412 PyObject * obj0 = 0 ;
21413 char *kwnames[] = {
21414 (char *) "self", NULL
21415 };
21416
21417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21419 if (SWIG_arg_fail(1)) SWIG_fail;
21420 {
21421 PyThreadState* __tstate = wxPyBeginAllowThreads();
21422 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21423
21424 wxPyEndAllowThreads(__tstate);
21425 if (PyErr_Occurred()) SWIG_fail;
21426 }
21427 {
21428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21429 }
21430 return resultobj;
21431 fail:
21432 return NULL;
21433 }
21434
21435
21436 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21437 PyObject *resultobj;
21438 wxIdleMode arg1 ;
21439 PyObject * obj0 = 0 ;
21440 char *kwnames[] = {
21441 (char *) "mode", NULL
21442 };
21443
21444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21445 {
21446 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21447 if (SWIG_arg_fail(1)) SWIG_fail;
21448 }
21449 {
21450 PyThreadState* __tstate = wxPyBeginAllowThreads();
21451 wxIdleEvent::SetMode((wxIdleMode )arg1);
21452
21453 wxPyEndAllowThreads(__tstate);
21454 if (PyErr_Occurred()) SWIG_fail;
21455 }
21456 Py_INCREF(Py_None); resultobj = Py_None;
21457 return resultobj;
21458 fail:
21459 return NULL;
21460 }
21461
21462
21463 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21464 PyObject *resultobj;
21465 wxIdleMode result;
21466 char *kwnames[] = {
21467 NULL
21468 };
21469
21470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21471 {
21472 PyThreadState* __tstate = wxPyBeginAllowThreads();
21473 result = (wxIdleMode)wxIdleEvent::GetMode();
21474
21475 wxPyEndAllowThreads(__tstate);
21476 if (PyErr_Occurred()) SWIG_fail;
21477 }
21478 resultobj = SWIG_From_int((result));
21479 return resultobj;
21480 fail:
21481 return NULL;
21482 }
21483
21484
21485 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
21486 PyObject *resultobj;
21487 wxWindow *arg1 = (wxWindow *) 0 ;
21488 bool result;
21489 PyObject * obj0 = 0 ;
21490 char *kwnames[] = {
21491 (char *) "win", NULL
21492 };
21493
21494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
21495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21496 if (SWIG_arg_fail(1)) SWIG_fail;
21497 {
21498 PyThreadState* __tstate = wxPyBeginAllowThreads();
21499 result = (bool)wxIdleEvent::CanSend(arg1);
21500
21501 wxPyEndAllowThreads(__tstate);
21502 if (PyErr_Occurred()) SWIG_fail;
21503 }
21504 {
21505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21506 }
21507 return resultobj;
21508 fail:
21509 return NULL;
21510 }
21511
21512
21513 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
21514 PyObject *obj;
21515 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21516 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
21517 Py_INCREF(obj);
21518 return Py_BuildValue((char *)"");
21519 }
21520 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21521 PyObject *resultobj;
21522 int arg1 = (int) 0 ;
21523 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
21524 wxPyEvent *result;
21525 PyObject * obj0 = 0 ;
21526 PyObject * obj1 = 0 ;
21527 char *kwnames[] = {
21528 (char *) "winid",(char *) "commandType", NULL
21529 };
21530
21531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
21532 if (obj0) {
21533 {
21534 arg1 = (int)(SWIG_As_int(obj0));
21535 if (SWIG_arg_fail(1)) SWIG_fail;
21536 }
21537 }
21538 if (obj1) {
21539 {
21540 arg2 = (wxEventType)(SWIG_As_int(obj1));
21541 if (SWIG_arg_fail(2)) SWIG_fail;
21542 }
21543 }
21544 {
21545 PyThreadState* __tstate = wxPyBeginAllowThreads();
21546 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
21547
21548 wxPyEndAllowThreads(__tstate);
21549 if (PyErr_Occurred()) SWIG_fail;
21550 }
21551 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
21552 return resultobj;
21553 fail:
21554 return NULL;
21555 }
21556
21557
21558 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21559 PyObject *resultobj;
21560 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21561 PyObject * obj0 = 0 ;
21562 char *kwnames[] = {
21563 (char *) "self", NULL
21564 };
21565
21566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
21567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21568 if (SWIG_arg_fail(1)) SWIG_fail;
21569 {
21570 PyThreadState* __tstate = wxPyBeginAllowThreads();
21571 delete arg1;
21572
21573 wxPyEndAllowThreads(__tstate);
21574 if (PyErr_Occurred()) SWIG_fail;
21575 }
21576 Py_INCREF(Py_None); resultobj = Py_None;
21577 return resultobj;
21578 fail:
21579 return NULL;
21580 }
21581
21582
21583 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21584 PyObject *resultobj;
21585 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21586 PyObject *arg2 = (PyObject *) 0 ;
21587 PyObject * obj0 = 0 ;
21588 PyObject * obj1 = 0 ;
21589 char *kwnames[] = {
21590 (char *) "self",(char *) "self", NULL
21591 };
21592
21593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21595 if (SWIG_arg_fail(1)) SWIG_fail;
21596 arg2 = obj1;
21597 {
21598 PyThreadState* __tstate = wxPyBeginAllowThreads();
21599 (arg1)->SetSelf(arg2);
21600
21601 wxPyEndAllowThreads(__tstate);
21602 if (PyErr_Occurred()) SWIG_fail;
21603 }
21604 Py_INCREF(Py_None); resultobj = Py_None;
21605 return resultobj;
21606 fail:
21607 return NULL;
21608 }
21609
21610
21611 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21612 PyObject *resultobj;
21613 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21614 PyObject *result;
21615 PyObject * obj0 = 0 ;
21616 char *kwnames[] = {
21617 (char *) "self", NULL
21618 };
21619
21620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
21621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21622 if (SWIG_arg_fail(1)) SWIG_fail;
21623 {
21624 PyThreadState* __tstate = wxPyBeginAllowThreads();
21625 result = (PyObject *)(arg1)->GetSelf();
21626
21627 wxPyEndAllowThreads(__tstate);
21628 if (PyErr_Occurred()) SWIG_fail;
21629 }
21630 resultobj = result;
21631 return resultobj;
21632 fail:
21633 return NULL;
21634 }
21635
21636
21637 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
21638 PyObject *obj;
21639 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21640 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
21641 Py_INCREF(obj);
21642 return Py_BuildValue((char *)"");
21643 }
21644 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21645 PyObject *resultobj;
21646 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21647 int arg2 = (int) 0 ;
21648 wxPyCommandEvent *result;
21649 PyObject * obj0 = 0 ;
21650 PyObject * obj1 = 0 ;
21651 char *kwnames[] = {
21652 (char *) "commandType",(char *) "id", NULL
21653 };
21654
21655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
21656 if (obj0) {
21657 {
21658 arg1 = (wxEventType)(SWIG_As_int(obj0));
21659 if (SWIG_arg_fail(1)) SWIG_fail;
21660 }
21661 }
21662 if (obj1) {
21663 {
21664 arg2 = (int)(SWIG_As_int(obj1));
21665 if (SWIG_arg_fail(2)) SWIG_fail;
21666 }
21667 }
21668 {
21669 PyThreadState* __tstate = wxPyBeginAllowThreads();
21670 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
21671
21672 wxPyEndAllowThreads(__tstate);
21673 if (PyErr_Occurred()) SWIG_fail;
21674 }
21675 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
21676 return resultobj;
21677 fail:
21678 return NULL;
21679 }
21680
21681
21682 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21683 PyObject *resultobj;
21684 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21685 PyObject * obj0 = 0 ;
21686 char *kwnames[] = {
21687 (char *) "self", NULL
21688 };
21689
21690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
21691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21692 if (SWIG_arg_fail(1)) SWIG_fail;
21693 {
21694 PyThreadState* __tstate = wxPyBeginAllowThreads();
21695 delete arg1;
21696
21697 wxPyEndAllowThreads(__tstate);
21698 if (PyErr_Occurred()) SWIG_fail;
21699 }
21700 Py_INCREF(Py_None); resultobj = Py_None;
21701 return resultobj;
21702 fail:
21703 return NULL;
21704 }
21705
21706
21707 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21708 PyObject *resultobj;
21709 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21710 PyObject *arg2 = (PyObject *) 0 ;
21711 PyObject * obj0 = 0 ;
21712 PyObject * obj1 = 0 ;
21713 char *kwnames[] = {
21714 (char *) "self",(char *) "self", NULL
21715 };
21716
21717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21719 if (SWIG_arg_fail(1)) SWIG_fail;
21720 arg2 = obj1;
21721 {
21722 PyThreadState* __tstate = wxPyBeginAllowThreads();
21723 (arg1)->SetSelf(arg2);
21724
21725 wxPyEndAllowThreads(__tstate);
21726 if (PyErr_Occurred()) SWIG_fail;
21727 }
21728 Py_INCREF(Py_None); resultobj = Py_None;
21729 return resultobj;
21730 fail:
21731 return NULL;
21732 }
21733
21734
21735 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21736 PyObject *resultobj;
21737 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21738 PyObject *result;
21739 PyObject * obj0 = 0 ;
21740 char *kwnames[] = {
21741 (char *) "self", NULL
21742 };
21743
21744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
21745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21746 if (SWIG_arg_fail(1)) SWIG_fail;
21747 {
21748 PyThreadState* __tstate = wxPyBeginAllowThreads();
21749 result = (PyObject *)(arg1)->GetSelf();
21750
21751 wxPyEndAllowThreads(__tstate);
21752 if (PyErr_Occurred()) SWIG_fail;
21753 }
21754 resultobj = result;
21755 return resultobj;
21756 fail:
21757 return NULL;
21758 }
21759
21760
21761 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
21762 PyObject *obj;
21763 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21764 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
21765 Py_INCREF(obj);
21766 return Py_BuildValue((char *)"");
21767 }
21768 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21769 PyObject *resultobj;
21770 wxWindow *arg1 = (wxWindow *) 0 ;
21771 wxDateTime *arg2 = 0 ;
21772 wxEventType arg3 ;
21773 wxDateEvent *result;
21774 PyObject * obj0 = 0 ;
21775 PyObject * obj1 = 0 ;
21776 PyObject * obj2 = 0 ;
21777 char *kwnames[] = {
21778 (char *) "win",(char *) "dt",(char *) "type", NULL
21779 };
21780
21781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21783 if (SWIG_arg_fail(1)) SWIG_fail;
21784 {
21785 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21786 if (SWIG_arg_fail(2)) SWIG_fail;
21787 if (arg2 == NULL) {
21788 SWIG_null_ref("wxDateTime");
21789 }
21790 if (SWIG_arg_fail(2)) SWIG_fail;
21791 }
21792 {
21793 arg3 = (wxEventType)(SWIG_As_int(obj2));
21794 if (SWIG_arg_fail(3)) SWIG_fail;
21795 }
21796 {
21797 PyThreadState* __tstate = wxPyBeginAllowThreads();
21798 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
21799
21800 wxPyEndAllowThreads(__tstate);
21801 if (PyErr_Occurred()) SWIG_fail;
21802 }
21803 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
21804 return resultobj;
21805 fail:
21806 return NULL;
21807 }
21808
21809
21810 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
21811 PyObject *resultobj;
21812 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
21813 wxDateTime *result;
21814 PyObject * obj0 = 0 ;
21815 char *kwnames[] = {
21816 (char *) "self", NULL
21817 };
21818
21819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
21820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
21821 if (SWIG_arg_fail(1)) SWIG_fail;
21822 {
21823 PyThreadState* __tstate = wxPyBeginAllowThreads();
21824 {
21825 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
21826 result = (wxDateTime *) &_result_ref;
21827 }
21828
21829 wxPyEndAllowThreads(__tstate);
21830 if (PyErr_Occurred()) SWIG_fail;
21831 }
21832 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21833 return resultobj;
21834 fail:
21835 return NULL;
21836 }
21837
21838
21839 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
21840 PyObject *resultobj;
21841 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
21842 wxDateTime *arg2 = 0 ;
21843 PyObject * obj0 = 0 ;
21844 PyObject * obj1 = 0 ;
21845 char *kwnames[] = {
21846 (char *) "self",(char *) "date", NULL
21847 };
21848
21849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
21850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
21851 if (SWIG_arg_fail(1)) SWIG_fail;
21852 {
21853 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21854 if (SWIG_arg_fail(2)) SWIG_fail;
21855 if (arg2 == NULL) {
21856 SWIG_null_ref("wxDateTime");
21857 }
21858 if (SWIG_arg_fail(2)) SWIG_fail;
21859 }
21860 {
21861 PyThreadState* __tstate = wxPyBeginAllowThreads();
21862 (arg1)->SetDate((wxDateTime const &)*arg2);
21863
21864 wxPyEndAllowThreads(__tstate);
21865 if (PyErr_Occurred()) SWIG_fail;
21866 }
21867 Py_INCREF(Py_None); resultobj = Py_None;
21868 return resultobj;
21869 fail:
21870 return NULL;
21871 }
21872
21873
21874 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
21875 PyObject *obj;
21876 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21877 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
21878 Py_INCREF(obj);
21879 return Py_BuildValue((char *)"");
21880 }
21881 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
21882 PyObject *resultobj;
21883 wxPyApp *result;
21884 char *kwnames[] = {
21885 NULL
21886 };
21887
21888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
21889 {
21890 PyThreadState* __tstate = wxPyBeginAllowThreads();
21891 result = (wxPyApp *)new_wxPyApp();
21892
21893 wxPyEndAllowThreads(__tstate);
21894 if (PyErr_Occurred()) SWIG_fail;
21895 }
21896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
21897 return resultobj;
21898 fail:
21899 return NULL;
21900 }
21901
21902
21903 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
21904 PyObject *resultobj;
21905 wxPyApp *arg1 = (wxPyApp *) 0 ;
21906 PyObject * obj0 = 0 ;
21907 char *kwnames[] = {
21908 (char *) "self", NULL
21909 };
21910
21911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
21912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21913 if (SWIG_arg_fail(1)) SWIG_fail;
21914 {
21915 PyThreadState* __tstate = wxPyBeginAllowThreads();
21916 delete arg1;
21917
21918 wxPyEndAllowThreads(__tstate);
21919 if (PyErr_Occurred()) SWIG_fail;
21920 }
21921 Py_INCREF(Py_None); resultobj = Py_None;
21922 return resultobj;
21923 fail:
21924 return NULL;
21925 }
21926
21927
21928 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
21929 PyObject *resultobj;
21930 wxPyApp *arg1 = (wxPyApp *) 0 ;
21931 PyObject *arg2 = (PyObject *) 0 ;
21932 PyObject *arg3 = (PyObject *) 0 ;
21933 PyObject * obj0 = 0 ;
21934 PyObject * obj1 = 0 ;
21935 PyObject * obj2 = 0 ;
21936 char *kwnames[] = {
21937 (char *) "self",(char *) "self",(char *) "_class", NULL
21938 };
21939
21940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
21941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21942 if (SWIG_arg_fail(1)) SWIG_fail;
21943 arg2 = obj1;
21944 arg3 = obj2;
21945 {
21946 PyThreadState* __tstate = wxPyBeginAllowThreads();
21947 (arg1)->_setCallbackInfo(arg2,arg3);
21948
21949 wxPyEndAllowThreads(__tstate);
21950 if (PyErr_Occurred()) SWIG_fail;
21951 }
21952 Py_INCREF(Py_None); resultobj = Py_None;
21953 return resultobj;
21954 fail:
21955 return NULL;
21956 }
21957
21958
21959 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
21960 PyObject *resultobj;
21961 wxPyApp *arg1 = (wxPyApp *) 0 ;
21962 wxString result;
21963 PyObject * obj0 = 0 ;
21964 char *kwnames[] = {
21965 (char *) "self", NULL
21966 };
21967
21968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
21969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21970 if (SWIG_arg_fail(1)) SWIG_fail;
21971 {
21972 PyThreadState* __tstate = wxPyBeginAllowThreads();
21973 result = ((wxPyApp const *)arg1)->GetAppName();
21974
21975 wxPyEndAllowThreads(__tstate);
21976 if (PyErr_Occurred()) SWIG_fail;
21977 }
21978 {
21979 #if wxUSE_UNICODE
21980 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21981 #else
21982 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21983 #endif
21984 }
21985 return resultobj;
21986 fail:
21987 return NULL;
21988 }
21989
21990
21991 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
21992 PyObject *resultobj;
21993 wxPyApp *arg1 = (wxPyApp *) 0 ;
21994 wxString *arg2 = 0 ;
21995 bool temp2 = false ;
21996 PyObject * obj0 = 0 ;
21997 PyObject * obj1 = 0 ;
21998 char *kwnames[] = {
21999 (char *) "self",(char *) "name", NULL
22000 };
22001
22002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22004 if (SWIG_arg_fail(1)) SWIG_fail;
22005 {
22006 arg2 = wxString_in_helper(obj1);
22007 if (arg2 == NULL) SWIG_fail;
22008 temp2 = true;
22009 }
22010 {
22011 PyThreadState* __tstate = wxPyBeginAllowThreads();
22012 (arg1)->SetAppName((wxString const &)*arg2);
22013
22014 wxPyEndAllowThreads(__tstate);
22015 if (PyErr_Occurred()) SWIG_fail;
22016 }
22017 Py_INCREF(Py_None); resultobj = Py_None;
22018 {
22019 if (temp2)
22020 delete arg2;
22021 }
22022 return resultobj;
22023 fail:
22024 {
22025 if (temp2)
22026 delete arg2;
22027 }
22028 return NULL;
22029 }
22030
22031
22032 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22033 PyObject *resultobj;
22034 wxPyApp *arg1 = (wxPyApp *) 0 ;
22035 wxString result;
22036 PyObject * obj0 = 0 ;
22037 char *kwnames[] = {
22038 (char *) "self", NULL
22039 };
22040
22041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22043 if (SWIG_arg_fail(1)) SWIG_fail;
22044 {
22045 PyThreadState* __tstate = wxPyBeginAllowThreads();
22046 result = ((wxPyApp const *)arg1)->GetClassName();
22047
22048 wxPyEndAllowThreads(__tstate);
22049 if (PyErr_Occurred()) SWIG_fail;
22050 }
22051 {
22052 #if wxUSE_UNICODE
22053 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22054 #else
22055 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22056 #endif
22057 }
22058 return resultobj;
22059 fail:
22060 return NULL;
22061 }
22062
22063
22064 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22065 PyObject *resultobj;
22066 wxPyApp *arg1 = (wxPyApp *) 0 ;
22067 wxString *arg2 = 0 ;
22068 bool temp2 = false ;
22069 PyObject * obj0 = 0 ;
22070 PyObject * obj1 = 0 ;
22071 char *kwnames[] = {
22072 (char *) "self",(char *) "name", NULL
22073 };
22074
22075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22077 if (SWIG_arg_fail(1)) SWIG_fail;
22078 {
22079 arg2 = wxString_in_helper(obj1);
22080 if (arg2 == NULL) SWIG_fail;
22081 temp2 = true;
22082 }
22083 {
22084 PyThreadState* __tstate = wxPyBeginAllowThreads();
22085 (arg1)->SetClassName((wxString const &)*arg2);
22086
22087 wxPyEndAllowThreads(__tstate);
22088 if (PyErr_Occurred()) SWIG_fail;
22089 }
22090 Py_INCREF(Py_None); resultobj = Py_None;
22091 {
22092 if (temp2)
22093 delete arg2;
22094 }
22095 return resultobj;
22096 fail:
22097 {
22098 if (temp2)
22099 delete arg2;
22100 }
22101 return NULL;
22102 }
22103
22104
22105 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22106 PyObject *resultobj;
22107 wxPyApp *arg1 = (wxPyApp *) 0 ;
22108 wxString *result;
22109 PyObject * obj0 = 0 ;
22110 char *kwnames[] = {
22111 (char *) "self", NULL
22112 };
22113
22114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22116 if (SWIG_arg_fail(1)) SWIG_fail;
22117 {
22118 PyThreadState* __tstate = wxPyBeginAllowThreads();
22119 {
22120 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22121 result = (wxString *) &_result_ref;
22122 }
22123
22124 wxPyEndAllowThreads(__tstate);
22125 if (PyErr_Occurred()) SWIG_fail;
22126 }
22127 {
22128 #if wxUSE_UNICODE
22129 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22130 #else
22131 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22132 #endif
22133 }
22134 return resultobj;
22135 fail:
22136 return NULL;
22137 }
22138
22139
22140 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22141 PyObject *resultobj;
22142 wxPyApp *arg1 = (wxPyApp *) 0 ;
22143 wxString *arg2 = 0 ;
22144 bool temp2 = false ;
22145 PyObject * obj0 = 0 ;
22146 PyObject * obj1 = 0 ;
22147 char *kwnames[] = {
22148 (char *) "self",(char *) "name", NULL
22149 };
22150
22151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22153 if (SWIG_arg_fail(1)) SWIG_fail;
22154 {
22155 arg2 = wxString_in_helper(obj1);
22156 if (arg2 == NULL) SWIG_fail;
22157 temp2 = true;
22158 }
22159 {
22160 PyThreadState* __tstate = wxPyBeginAllowThreads();
22161 (arg1)->SetVendorName((wxString const &)*arg2);
22162
22163 wxPyEndAllowThreads(__tstate);
22164 if (PyErr_Occurred()) SWIG_fail;
22165 }
22166 Py_INCREF(Py_None); resultobj = Py_None;
22167 {
22168 if (temp2)
22169 delete arg2;
22170 }
22171 return resultobj;
22172 fail:
22173 {
22174 if (temp2)
22175 delete arg2;
22176 }
22177 return NULL;
22178 }
22179
22180
22181 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22182 PyObject *resultobj;
22183 wxPyApp *arg1 = (wxPyApp *) 0 ;
22184 wxAppTraits *result;
22185 PyObject * obj0 = 0 ;
22186 char *kwnames[] = {
22187 (char *) "self", NULL
22188 };
22189
22190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22192 if (SWIG_arg_fail(1)) SWIG_fail;
22193 {
22194 PyThreadState* __tstate = wxPyBeginAllowThreads();
22195 result = (wxAppTraits *)(arg1)->GetTraits();
22196
22197 wxPyEndAllowThreads(__tstate);
22198 if (PyErr_Occurred()) SWIG_fail;
22199 }
22200 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22201 return resultobj;
22202 fail:
22203 return NULL;
22204 }
22205
22206
22207 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22208 PyObject *resultobj;
22209 wxPyApp *arg1 = (wxPyApp *) 0 ;
22210 PyObject * obj0 = 0 ;
22211 char *kwnames[] = {
22212 (char *) "self", NULL
22213 };
22214
22215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22217 if (SWIG_arg_fail(1)) SWIG_fail;
22218 {
22219 PyThreadState* __tstate = wxPyBeginAllowThreads();
22220 (arg1)->ProcessPendingEvents();
22221
22222 wxPyEndAllowThreads(__tstate);
22223 if (PyErr_Occurred()) SWIG_fail;
22224 }
22225 Py_INCREF(Py_None); resultobj = Py_None;
22226 return resultobj;
22227 fail:
22228 return NULL;
22229 }
22230
22231
22232 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22233 PyObject *resultobj;
22234 wxPyApp *arg1 = (wxPyApp *) 0 ;
22235 bool arg2 = (bool) false ;
22236 bool result;
22237 PyObject * obj0 = 0 ;
22238 PyObject * obj1 = 0 ;
22239 char *kwnames[] = {
22240 (char *) "self",(char *) "onlyIfNeeded", NULL
22241 };
22242
22243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22245 if (SWIG_arg_fail(1)) SWIG_fail;
22246 if (obj1) {
22247 {
22248 arg2 = (bool)(SWIG_As_bool(obj1));
22249 if (SWIG_arg_fail(2)) SWIG_fail;
22250 }
22251 }
22252 {
22253 PyThreadState* __tstate = wxPyBeginAllowThreads();
22254 result = (bool)(arg1)->Yield(arg2);
22255
22256 wxPyEndAllowThreads(__tstate);
22257 if (PyErr_Occurred()) SWIG_fail;
22258 }
22259 {
22260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22261 }
22262 return resultobj;
22263 fail:
22264 return NULL;
22265 }
22266
22267
22268 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22269 PyObject *resultobj;
22270 wxPyApp *arg1 = (wxPyApp *) 0 ;
22271 PyObject * obj0 = 0 ;
22272 char *kwnames[] = {
22273 (char *) "self", NULL
22274 };
22275
22276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22278 if (SWIG_arg_fail(1)) SWIG_fail;
22279 {
22280 PyThreadState* __tstate = wxPyBeginAllowThreads();
22281 (arg1)->WakeUpIdle();
22282
22283 wxPyEndAllowThreads(__tstate);
22284 if (PyErr_Occurred()) SWIG_fail;
22285 }
22286 Py_INCREF(Py_None); resultobj = Py_None;
22287 return resultobj;
22288 fail:
22289 return NULL;
22290 }
22291
22292
22293 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22294 PyObject *resultobj;
22295 bool result;
22296 char *kwnames[] = {
22297 NULL
22298 };
22299
22300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22301 {
22302 PyThreadState* __tstate = wxPyBeginAllowThreads();
22303 result = (bool)wxPyApp::IsMainLoopRunning();
22304
22305 wxPyEndAllowThreads(__tstate);
22306 if (PyErr_Occurred()) SWIG_fail;
22307 }
22308 {
22309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22310 }
22311 return resultobj;
22312 fail:
22313 return NULL;
22314 }
22315
22316
22317 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22318 PyObject *resultobj;
22319 wxPyApp *arg1 = (wxPyApp *) 0 ;
22320 int result;
22321 PyObject * obj0 = 0 ;
22322 char *kwnames[] = {
22323 (char *) "self", NULL
22324 };
22325
22326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22328 if (SWIG_arg_fail(1)) SWIG_fail;
22329 {
22330 PyThreadState* __tstate = wxPyBeginAllowThreads();
22331 result = (int)(arg1)->MainLoop();
22332
22333 wxPyEndAllowThreads(__tstate);
22334 if (PyErr_Occurred()) SWIG_fail;
22335 }
22336 {
22337 resultobj = SWIG_From_int((int)(result));
22338 }
22339 return resultobj;
22340 fail:
22341 return NULL;
22342 }
22343
22344
22345 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22346 PyObject *resultobj;
22347 wxPyApp *arg1 = (wxPyApp *) 0 ;
22348 PyObject * obj0 = 0 ;
22349 char *kwnames[] = {
22350 (char *) "self", NULL
22351 };
22352
22353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22355 if (SWIG_arg_fail(1)) SWIG_fail;
22356 {
22357 PyThreadState* __tstate = wxPyBeginAllowThreads();
22358 (arg1)->Exit();
22359
22360 wxPyEndAllowThreads(__tstate);
22361 if (PyErr_Occurred()) SWIG_fail;
22362 }
22363 Py_INCREF(Py_None); resultobj = Py_None;
22364 return resultobj;
22365 fail:
22366 return NULL;
22367 }
22368
22369
22370 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22371 PyObject *resultobj;
22372 wxPyApp *arg1 = (wxPyApp *) 0 ;
22373 PyObject * obj0 = 0 ;
22374 char *kwnames[] = {
22375 (char *) "self", NULL
22376 };
22377
22378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22380 if (SWIG_arg_fail(1)) SWIG_fail;
22381 {
22382 PyThreadState* __tstate = wxPyBeginAllowThreads();
22383 (arg1)->ExitMainLoop();
22384
22385 wxPyEndAllowThreads(__tstate);
22386 if (PyErr_Occurred()) SWIG_fail;
22387 }
22388 Py_INCREF(Py_None); resultobj = Py_None;
22389 return resultobj;
22390 fail:
22391 return NULL;
22392 }
22393
22394
22395 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22396 PyObject *resultobj;
22397 wxPyApp *arg1 = (wxPyApp *) 0 ;
22398 bool result;
22399 PyObject * obj0 = 0 ;
22400 char *kwnames[] = {
22401 (char *) "self", NULL
22402 };
22403
22404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22406 if (SWIG_arg_fail(1)) SWIG_fail;
22407 {
22408 PyThreadState* __tstate = wxPyBeginAllowThreads();
22409 result = (bool)(arg1)->Pending();
22410
22411 wxPyEndAllowThreads(__tstate);
22412 if (PyErr_Occurred()) SWIG_fail;
22413 }
22414 {
22415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22416 }
22417 return resultobj;
22418 fail:
22419 return NULL;
22420 }
22421
22422
22423 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22424 PyObject *resultobj;
22425 wxPyApp *arg1 = (wxPyApp *) 0 ;
22426 bool result;
22427 PyObject * obj0 = 0 ;
22428 char *kwnames[] = {
22429 (char *) "self", NULL
22430 };
22431
22432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22434 if (SWIG_arg_fail(1)) SWIG_fail;
22435 {
22436 PyThreadState* __tstate = wxPyBeginAllowThreads();
22437 result = (bool)(arg1)->Dispatch();
22438
22439 wxPyEndAllowThreads(__tstate);
22440 if (PyErr_Occurred()) SWIG_fail;
22441 }
22442 {
22443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22444 }
22445 return resultobj;
22446 fail:
22447 return NULL;
22448 }
22449
22450
22451 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22452 PyObject *resultobj;
22453 wxPyApp *arg1 = (wxPyApp *) 0 ;
22454 bool result;
22455 PyObject * obj0 = 0 ;
22456 char *kwnames[] = {
22457 (char *) "self", NULL
22458 };
22459
22460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22462 if (SWIG_arg_fail(1)) SWIG_fail;
22463 {
22464 PyThreadState* __tstate = wxPyBeginAllowThreads();
22465 result = (bool)(arg1)->ProcessIdle();
22466
22467 wxPyEndAllowThreads(__tstate);
22468 if (PyErr_Occurred()) SWIG_fail;
22469 }
22470 {
22471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22472 }
22473 return resultobj;
22474 fail:
22475 return NULL;
22476 }
22477
22478
22479 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22480 PyObject *resultobj;
22481 wxPyApp *arg1 = (wxPyApp *) 0 ;
22482 wxWindow *arg2 = (wxWindow *) 0 ;
22483 wxIdleEvent *arg3 = 0 ;
22484 bool result;
22485 PyObject * obj0 = 0 ;
22486 PyObject * obj1 = 0 ;
22487 PyObject * obj2 = 0 ;
22488 char *kwnames[] = {
22489 (char *) "self",(char *) "win",(char *) "event", NULL
22490 };
22491
22492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
22493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22494 if (SWIG_arg_fail(1)) SWIG_fail;
22495 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22496 if (SWIG_arg_fail(2)) SWIG_fail;
22497 {
22498 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22499 if (SWIG_arg_fail(3)) SWIG_fail;
22500 if (arg3 == NULL) {
22501 SWIG_null_ref("wxIdleEvent");
22502 }
22503 if (SWIG_arg_fail(3)) SWIG_fail;
22504 }
22505 {
22506 PyThreadState* __tstate = wxPyBeginAllowThreads();
22507 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
22508
22509 wxPyEndAllowThreads(__tstate);
22510 if (PyErr_Occurred()) SWIG_fail;
22511 }
22512 {
22513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22514 }
22515 return resultobj;
22516 fail:
22517 return NULL;
22518 }
22519
22520
22521 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
22522 PyObject *resultobj;
22523 wxPyApp *arg1 = (wxPyApp *) 0 ;
22524 bool result;
22525 PyObject * obj0 = 0 ;
22526 char *kwnames[] = {
22527 (char *) "self", NULL
22528 };
22529
22530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
22531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22532 if (SWIG_arg_fail(1)) SWIG_fail;
22533 {
22534 PyThreadState* __tstate = wxPyBeginAllowThreads();
22535 result = (bool)((wxPyApp const *)arg1)->IsActive();
22536
22537 wxPyEndAllowThreads(__tstate);
22538 if (PyErr_Occurred()) SWIG_fail;
22539 }
22540 {
22541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22542 }
22543 return resultobj;
22544 fail:
22545 return NULL;
22546 }
22547
22548
22549 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22550 PyObject *resultobj;
22551 wxPyApp *arg1 = (wxPyApp *) 0 ;
22552 wxWindow *arg2 = (wxWindow *) 0 ;
22553 PyObject * obj0 = 0 ;
22554 PyObject * obj1 = 0 ;
22555 char *kwnames[] = {
22556 (char *) "self",(char *) "win", NULL
22557 };
22558
22559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
22560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22561 if (SWIG_arg_fail(1)) SWIG_fail;
22562 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22563 if (SWIG_arg_fail(2)) SWIG_fail;
22564 {
22565 PyThreadState* __tstate = wxPyBeginAllowThreads();
22566 (arg1)->SetTopWindow(arg2);
22567
22568 wxPyEndAllowThreads(__tstate);
22569 if (PyErr_Occurred()) SWIG_fail;
22570 }
22571 Py_INCREF(Py_None); resultobj = Py_None;
22572 return resultobj;
22573 fail:
22574 return NULL;
22575 }
22576
22577
22578 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22579 PyObject *resultobj;
22580 wxPyApp *arg1 = (wxPyApp *) 0 ;
22581 wxWindow *result;
22582 PyObject * obj0 = 0 ;
22583 char *kwnames[] = {
22584 (char *) "self", NULL
22585 };
22586
22587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
22588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22589 if (SWIG_arg_fail(1)) SWIG_fail;
22590 {
22591 PyThreadState* __tstate = wxPyBeginAllowThreads();
22592 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
22593
22594 wxPyEndAllowThreads(__tstate);
22595 if (PyErr_Occurred()) SWIG_fail;
22596 }
22597 {
22598 resultobj = wxPyMake_wxObject(result, 0);
22599 }
22600 return resultobj;
22601 fail:
22602 return NULL;
22603 }
22604
22605
22606 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22607 PyObject *resultobj;
22608 wxPyApp *arg1 = (wxPyApp *) 0 ;
22609 bool arg2 ;
22610 PyObject * obj0 = 0 ;
22611 PyObject * obj1 = 0 ;
22612 char *kwnames[] = {
22613 (char *) "self",(char *) "flag", NULL
22614 };
22615
22616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
22617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22618 if (SWIG_arg_fail(1)) SWIG_fail;
22619 {
22620 arg2 = (bool)(SWIG_As_bool(obj1));
22621 if (SWIG_arg_fail(2)) SWIG_fail;
22622 }
22623 {
22624 PyThreadState* __tstate = wxPyBeginAllowThreads();
22625 (arg1)->SetExitOnFrameDelete(arg2);
22626
22627 wxPyEndAllowThreads(__tstate);
22628 if (PyErr_Occurred()) SWIG_fail;
22629 }
22630 Py_INCREF(Py_None); resultobj = Py_None;
22631 return resultobj;
22632 fail:
22633 return NULL;
22634 }
22635
22636
22637 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22638 PyObject *resultobj;
22639 wxPyApp *arg1 = (wxPyApp *) 0 ;
22640 bool result;
22641 PyObject * obj0 = 0 ;
22642 char *kwnames[] = {
22643 (char *) "self", NULL
22644 };
22645
22646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
22647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22648 if (SWIG_arg_fail(1)) SWIG_fail;
22649 {
22650 PyThreadState* __tstate = wxPyBeginAllowThreads();
22651 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
22652
22653 wxPyEndAllowThreads(__tstate);
22654 if (PyErr_Occurred()) SWIG_fail;
22655 }
22656 {
22657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22658 }
22659 return resultobj;
22660 fail:
22661 return NULL;
22662 }
22663
22664
22665 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22666 PyObject *resultobj;
22667 wxPyApp *arg1 = (wxPyApp *) 0 ;
22668 bool arg2 ;
22669 PyObject * obj0 = 0 ;
22670 PyObject * obj1 = 0 ;
22671 char *kwnames[] = {
22672 (char *) "self",(char *) "flag", NULL
22673 };
22674
22675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
22676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22677 if (SWIG_arg_fail(1)) SWIG_fail;
22678 {
22679 arg2 = (bool)(SWIG_As_bool(obj1));
22680 if (SWIG_arg_fail(2)) SWIG_fail;
22681 }
22682 {
22683 PyThreadState* __tstate = wxPyBeginAllowThreads();
22684 (arg1)->SetUseBestVisual(arg2);
22685
22686 wxPyEndAllowThreads(__tstate);
22687 if (PyErr_Occurred()) SWIG_fail;
22688 }
22689 Py_INCREF(Py_None); resultobj = Py_None;
22690 return resultobj;
22691 fail:
22692 return NULL;
22693 }
22694
22695
22696 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22697 PyObject *resultobj;
22698 wxPyApp *arg1 = (wxPyApp *) 0 ;
22699 bool result;
22700 PyObject * obj0 = 0 ;
22701 char *kwnames[] = {
22702 (char *) "self", NULL
22703 };
22704
22705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
22706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22707 if (SWIG_arg_fail(1)) SWIG_fail;
22708 {
22709 PyThreadState* __tstate = wxPyBeginAllowThreads();
22710 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
22711
22712 wxPyEndAllowThreads(__tstate);
22713 if (PyErr_Occurred()) SWIG_fail;
22714 }
22715 {
22716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22717 }
22718 return resultobj;
22719 fail:
22720 return NULL;
22721 }
22722
22723
22724 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22725 PyObject *resultobj;
22726 wxPyApp *arg1 = (wxPyApp *) 0 ;
22727 int arg2 ;
22728 PyObject * obj0 = 0 ;
22729 PyObject * obj1 = 0 ;
22730 char *kwnames[] = {
22731 (char *) "self",(char *) "mode", NULL
22732 };
22733
22734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
22735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22736 if (SWIG_arg_fail(1)) SWIG_fail;
22737 {
22738 arg2 = (int)(SWIG_As_int(obj1));
22739 if (SWIG_arg_fail(2)) SWIG_fail;
22740 }
22741 {
22742 PyThreadState* __tstate = wxPyBeginAllowThreads();
22743 (arg1)->SetPrintMode(arg2);
22744
22745 wxPyEndAllowThreads(__tstate);
22746 if (PyErr_Occurred()) SWIG_fail;
22747 }
22748 Py_INCREF(Py_None); resultobj = Py_None;
22749 return resultobj;
22750 fail:
22751 return NULL;
22752 }
22753
22754
22755 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22756 PyObject *resultobj;
22757 wxPyApp *arg1 = (wxPyApp *) 0 ;
22758 int result;
22759 PyObject * obj0 = 0 ;
22760 char *kwnames[] = {
22761 (char *) "self", NULL
22762 };
22763
22764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
22765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22766 if (SWIG_arg_fail(1)) SWIG_fail;
22767 {
22768 PyThreadState* __tstate = wxPyBeginAllowThreads();
22769 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
22770
22771 wxPyEndAllowThreads(__tstate);
22772 if (PyErr_Occurred()) SWIG_fail;
22773 }
22774 {
22775 resultobj = SWIG_From_int((int)(result));
22776 }
22777 return resultobj;
22778 fail:
22779 return NULL;
22780 }
22781
22782
22783 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
22784 PyObject *resultobj;
22785 wxPyApp *arg1 = (wxPyApp *) 0 ;
22786 int arg2 ;
22787 PyObject * obj0 = 0 ;
22788 PyObject * obj1 = 0 ;
22789 char *kwnames[] = {
22790 (char *) "self",(char *) "mode", NULL
22791 };
22792
22793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
22794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22795 if (SWIG_arg_fail(1)) SWIG_fail;
22796 {
22797 arg2 = (int)(SWIG_As_int(obj1));
22798 if (SWIG_arg_fail(2)) SWIG_fail;
22799 }
22800 {
22801 PyThreadState* __tstate = wxPyBeginAllowThreads();
22802 (arg1)->SetAssertMode(arg2);
22803
22804 wxPyEndAllowThreads(__tstate);
22805 if (PyErr_Occurred()) SWIG_fail;
22806 }
22807 Py_INCREF(Py_None); resultobj = Py_None;
22808 return resultobj;
22809 fail:
22810 return NULL;
22811 }
22812
22813
22814 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
22815 PyObject *resultobj;
22816 wxPyApp *arg1 = (wxPyApp *) 0 ;
22817 int result;
22818 PyObject * obj0 = 0 ;
22819 char *kwnames[] = {
22820 (char *) "self", NULL
22821 };
22822
22823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
22824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22825 if (SWIG_arg_fail(1)) SWIG_fail;
22826 {
22827 PyThreadState* __tstate = wxPyBeginAllowThreads();
22828 result = (int)(arg1)->GetAssertMode();
22829
22830 wxPyEndAllowThreads(__tstate);
22831 if (PyErr_Occurred()) SWIG_fail;
22832 }
22833 {
22834 resultobj = SWIG_From_int((int)(result));
22835 }
22836 return resultobj;
22837 fail:
22838 return NULL;
22839 }
22840
22841
22842 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
22843 PyObject *resultobj;
22844 bool result;
22845 char *kwnames[] = {
22846 NULL
22847 };
22848
22849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
22850 {
22851 PyThreadState* __tstate = wxPyBeginAllowThreads();
22852 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
22853
22854 wxPyEndAllowThreads(__tstate);
22855 if (PyErr_Occurred()) SWIG_fail;
22856 }
22857 {
22858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22859 }
22860 return resultobj;
22861 fail:
22862 return NULL;
22863 }
22864
22865
22866 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22867 PyObject *resultobj;
22868 long result;
22869 char *kwnames[] = {
22870 NULL
22871 };
22872
22873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
22874 {
22875 PyThreadState* __tstate = wxPyBeginAllowThreads();
22876 result = (long)wxPyApp::GetMacAboutMenuItemId();
22877
22878 wxPyEndAllowThreads(__tstate);
22879 if (PyErr_Occurred()) SWIG_fail;
22880 }
22881 {
22882 resultobj = SWIG_From_long((long)(result));
22883 }
22884 return resultobj;
22885 fail:
22886 return NULL;
22887 }
22888
22889
22890 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22891 PyObject *resultobj;
22892 long result;
22893 char *kwnames[] = {
22894 NULL
22895 };
22896
22897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
22898 {
22899 PyThreadState* __tstate = wxPyBeginAllowThreads();
22900 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
22901
22902 wxPyEndAllowThreads(__tstate);
22903 if (PyErr_Occurred()) SWIG_fail;
22904 }
22905 {
22906 resultobj = SWIG_From_long((long)(result));
22907 }
22908 return resultobj;
22909 fail:
22910 return NULL;
22911 }
22912
22913
22914 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22915 PyObject *resultobj;
22916 long result;
22917 char *kwnames[] = {
22918 NULL
22919 };
22920
22921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
22922 {
22923 PyThreadState* __tstate = wxPyBeginAllowThreads();
22924 result = (long)wxPyApp::GetMacExitMenuItemId();
22925
22926 wxPyEndAllowThreads(__tstate);
22927 if (PyErr_Occurred()) SWIG_fail;
22928 }
22929 {
22930 resultobj = SWIG_From_long((long)(result));
22931 }
22932 return resultobj;
22933 fail:
22934 return NULL;
22935 }
22936
22937
22938 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
22939 PyObject *resultobj;
22940 wxString result;
22941 char *kwnames[] = {
22942 NULL
22943 };
22944
22945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
22946 {
22947 PyThreadState* __tstate = wxPyBeginAllowThreads();
22948 result = wxPyApp::GetMacHelpMenuTitleName();
22949
22950 wxPyEndAllowThreads(__tstate);
22951 if (PyErr_Occurred()) SWIG_fail;
22952 }
22953 {
22954 #if wxUSE_UNICODE
22955 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22956 #else
22957 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22958 #endif
22959 }
22960 return resultobj;
22961 fail:
22962 return NULL;
22963 }
22964
22965
22966 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
22967 PyObject *resultobj;
22968 bool arg1 ;
22969 PyObject * obj0 = 0 ;
22970 char *kwnames[] = {
22971 (char *) "val", NULL
22972 };
22973
22974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
22975 {
22976 arg1 = (bool)(SWIG_As_bool(obj0));
22977 if (SWIG_arg_fail(1)) SWIG_fail;
22978 }
22979 {
22980 PyThreadState* __tstate = wxPyBeginAllowThreads();
22981 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
22982
22983 wxPyEndAllowThreads(__tstate);
22984 if (PyErr_Occurred()) SWIG_fail;
22985 }
22986 Py_INCREF(Py_None); resultobj = Py_None;
22987 return resultobj;
22988 fail:
22989 return NULL;
22990 }
22991
22992
22993 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22994 PyObject *resultobj;
22995 long arg1 ;
22996 PyObject * obj0 = 0 ;
22997 char *kwnames[] = {
22998 (char *) "val", NULL
22999 };
23000
23001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23002 {
23003 arg1 = (long)(SWIG_As_long(obj0));
23004 if (SWIG_arg_fail(1)) SWIG_fail;
23005 }
23006 {
23007 PyThreadState* __tstate = wxPyBeginAllowThreads();
23008 wxPyApp::SetMacAboutMenuItemId(arg1);
23009
23010 wxPyEndAllowThreads(__tstate);
23011 if (PyErr_Occurred()) SWIG_fail;
23012 }
23013 Py_INCREF(Py_None); resultobj = Py_None;
23014 return resultobj;
23015 fail:
23016 return NULL;
23017 }
23018
23019
23020 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23021 PyObject *resultobj;
23022 long arg1 ;
23023 PyObject * obj0 = 0 ;
23024 char *kwnames[] = {
23025 (char *) "val", NULL
23026 };
23027
23028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23029 {
23030 arg1 = (long)(SWIG_As_long(obj0));
23031 if (SWIG_arg_fail(1)) SWIG_fail;
23032 }
23033 {
23034 PyThreadState* __tstate = wxPyBeginAllowThreads();
23035 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23036
23037 wxPyEndAllowThreads(__tstate);
23038 if (PyErr_Occurred()) SWIG_fail;
23039 }
23040 Py_INCREF(Py_None); resultobj = Py_None;
23041 return resultobj;
23042 fail:
23043 return NULL;
23044 }
23045
23046
23047 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23048 PyObject *resultobj;
23049 long arg1 ;
23050 PyObject * obj0 = 0 ;
23051 char *kwnames[] = {
23052 (char *) "val", NULL
23053 };
23054
23055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23056 {
23057 arg1 = (long)(SWIG_As_long(obj0));
23058 if (SWIG_arg_fail(1)) SWIG_fail;
23059 }
23060 {
23061 PyThreadState* __tstate = wxPyBeginAllowThreads();
23062 wxPyApp::SetMacExitMenuItemId(arg1);
23063
23064 wxPyEndAllowThreads(__tstate);
23065 if (PyErr_Occurred()) SWIG_fail;
23066 }
23067 Py_INCREF(Py_None); resultobj = Py_None;
23068 return resultobj;
23069 fail:
23070 return NULL;
23071 }
23072
23073
23074 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23075 PyObject *resultobj;
23076 wxString *arg1 = 0 ;
23077 bool temp1 = false ;
23078 PyObject * obj0 = 0 ;
23079 char *kwnames[] = {
23080 (char *) "val", NULL
23081 };
23082
23083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23084 {
23085 arg1 = wxString_in_helper(obj0);
23086 if (arg1 == NULL) SWIG_fail;
23087 temp1 = true;
23088 }
23089 {
23090 PyThreadState* __tstate = wxPyBeginAllowThreads();
23091 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23092
23093 wxPyEndAllowThreads(__tstate);
23094 if (PyErr_Occurred()) SWIG_fail;
23095 }
23096 Py_INCREF(Py_None); resultobj = Py_None;
23097 {
23098 if (temp1)
23099 delete arg1;
23100 }
23101 return resultobj;
23102 fail:
23103 {
23104 if (temp1)
23105 delete arg1;
23106 }
23107 return NULL;
23108 }
23109
23110
23111 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23112 PyObject *resultobj;
23113 wxPyApp *arg1 = (wxPyApp *) 0 ;
23114 PyObject * obj0 = 0 ;
23115 char *kwnames[] = {
23116 (char *) "self", NULL
23117 };
23118
23119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23121 if (SWIG_arg_fail(1)) SWIG_fail;
23122 {
23123 PyThreadState* __tstate = wxPyBeginAllowThreads();
23124 (arg1)->_BootstrapApp();
23125
23126 wxPyEndAllowThreads(__tstate);
23127 if (PyErr_Occurred()) SWIG_fail;
23128 }
23129 Py_INCREF(Py_None); resultobj = Py_None;
23130 return resultobj;
23131 fail:
23132 return NULL;
23133 }
23134
23135
23136 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23137 PyObject *resultobj;
23138 int result;
23139 char *kwnames[] = {
23140 NULL
23141 };
23142
23143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23144 {
23145 PyThreadState* __tstate = wxPyBeginAllowThreads();
23146 result = (int)PyApp_GetComCtl32Version();
23147
23148 wxPyEndAllowThreads(__tstate);
23149 if (PyErr_Occurred()) SWIG_fail;
23150 }
23151 {
23152 resultobj = SWIG_From_int((int)(result));
23153 }
23154 return resultobj;
23155 fail:
23156 return NULL;
23157 }
23158
23159
23160 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23161 PyObject *obj;
23162 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23163 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23164 Py_INCREF(obj);
23165 return Py_BuildValue((char *)"");
23166 }
23167 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23168 PyObject *resultobj;
23169 char *kwnames[] = {
23170 NULL
23171 };
23172
23173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23174 {
23175 PyThreadState* __tstate = wxPyBeginAllowThreads();
23176 wxExit();
23177
23178 wxPyEndAllowThreads(__tstate);
23179 if (PyErr_Occurred()) SWIG_fail;
23180 }
23181 Py_INCREF(Py_None); resultobj = Py_None;
23182 return resultobj;
23183 fail:
23184 return NULL;
23185 }
23186
23187
23188 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23189 PyObject *resultobj;
23190 bool result;
23191 char *kwnames[] = {
23192 NULL
23193 };
23194
23195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23196 {
23197 PyThreadState* __tstate = wxPyBeginAllowThreads();
23198 result = (bool)wxYield();
23199
23200 wxPyEndAllowThreads(__tstate);
23201 if (PyErr_Occurred()) SWIG_fail;
23202 }
23203 {
23204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23205 }
23206 return resultobj;
23207 fail:
23208 return NULL;
23209 }
23210
23211
23212 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23213 PyObject *resultobj;
23214 bool result;
23215 char *kwnames[] = {
23216 NULL
23217 };
23218
23219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23220 {
23221 PyThreadState* __tstate = wxPyBeginAllowThreads();
23222 result = (bool)wxYieldIfNeeded();
23223
23224 wxPyEndAllowThreads(__tstate);
23225 if (PyErr_Occurred()) SWIG_fail;
23226 }
23227 {
23228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23229 }
23230 return resultobj;
23231 fail:
23232 return NULL;
23233 }
23234
23235
23236 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23237 PyObject *resultobj;
23238 wxWindow *arg1 = (wxWindow *) NULL ;
23239 bool arg2 = (bool) false ;
23240 bool result;
23241 PyObject * obj0 = 0 ;
23242 PyObject * obj1 = 0 ;
23243 char *kwnames[] = {
23244 (char *) "win",(char *) "onlyIfNeeded", NULL
23245 };
23246
23247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23248 if (obj0) {
23249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23250 if (SWIG_arg_fail(1)) SWIG_fail;
23251 }
23252 if (obj1) {
23253 {
23254 arg2 = (bool)(SWIG_As_bool(obj1));
23255 if (SWIG_arg_fail(2)) SWIG_fail;
23256 }
23257 }
23258 {
23259 PyThreadState* __tstate = wxPyBeginAllowThreads();
23260 result = (bool)wxSafeYield(arg1,arg2);
23261
23262 wxPyEndAllowThreads(__tstate);
23263 if (PyErr_Occurred()) SWIG_fail;
23264 }
23265 {
23266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23267 }
23268 return resultobj;
23269 fail:
23270 return NULL;
23271 }
23272
23273
23274 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23275 PyObject *resultobj;
23276 char *kwnames[] = {
23277 NULL
23278 };
23279
23280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23281 {
23282 PyThreadState* __tstate = wxPyBeginAllowThreads();
23283 wxWakeUpIdle();
23284
23285 wxPyEndAllowThreads(__tstate);
23286 if (PyErr_Occurred()) SWIG_fail;
23287 }
23288 Py_INCREF(Py_None); resultobj = Py_None;
23289 return resultobj;
23290 fail:
23291 return NULL;
23292 }
23293
23294
23295 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23296 PyObject *resultobj;
23297 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23298 wxEvent *arg2 = 0 ;
23299 PyObject * obj0 = 0 ;
23300 PyObject * obj1 = 0 ;
23301 char *kwnames[] = {
23302 (char *) "dest",(char *) "event", NULL
23303 };
23304
23305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23307 if (SWIG_arg_fail(1)) SWIG_fail;
23308 {
23309 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23310 if (SWIG_arg_fail(2)) SWIG_fail;
23311 if (arg2 == NULL) {
23312 SWIG_null_ref("wxEvent");
23313 }
23314 if (SWIG_arg_fail(2)) SWIG_fail;
23315 }
23316 {
23317 PyThreadState* __tstate = wxPyBeginAllowThreads();
23318 wxPostEvent(arg1,*arg2);
23319
23320 wxPyEndAllowThreads(__tstate);
23321 if (PyErr_Occurred()) SWIG_fail;
23322 }
23323 Py_INCREF(Py_None); resultobj = Py_None;
23324 return resultobj;
23325 fail:
23326 return NULL;
23327 }
23328
23329
23330 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23331 PyObject *resultobj;
23332 char *kwnames[] = {
23333 NULL
23334 };
23335
23336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23337 {
23338 PyThreadState* __tstate = wxPyBeginAllowThreads();
23339 wxApp_CleanUp();
23340
23341 wxPyEndAllowThreads(__tstate);
23342 if (PyErr_Occurred()) SWIG_fail;
23343 }
23344 Py_INCREF(Py_None); resultobj = Py_None;
23345 return resultobj;
23346 fail:
23347 return NULL;
23348 }
23349
23350
23351 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23352 PyObject *resultobj;
23353 wxPyApp *result;
23354 char *kwnames[] = {
23355 NULL
23356 };
23357
23358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23359 {
23360 PyThreadState* __tstate = wxPyBeginAllowThreads();
23361 result = (wxPyApp *)wxPyGetApp();
23362
23363 wxPyEndAllowThreads(__tstate);
23364 if (PyErr_Occurred()) SWIG_fail;
23365 }
23366 {
23367 resultobj = wxPyMake_wxObject(result, 0);
23368 }
23369 return resultobj;
23370 fail:
23371 return NULL;
23372 }
23373
23374
23375 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23376 PyObject *resultobj;
23377 char *arg1 = (char *) 0 ;
23378 PyObject * obj0 = 0 ;
23379 char *kwnames[] = {
23380 (char *) "encoding", NULL
23381 };
23382
23383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23384 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23385 SWIG_arg_fail(1);SWIG_fail;
23386 }
23387 {
23388 PyThreadState* __tstate = wxPyBeginAllowThreads();
23389 wxSetDefaultPyEncoding((char const *)arg1);
23390
23391 wxPyEndAllowThreads(__tstate);
23392 if (PyErr_Occurred()) SWIG_fail;
23393 }
23394 Py_INCREF(Py_None); resultobj = Py_None;
23395 return resultobj;
23396 fail:
23397 return NULL;
23398 }
23399
23400
23401 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23402 PyObject *resultobj;
23403 char *result;
23404 char *kwnames[] = {
23405 NULL
23406 };
23407
23408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23409 {
23410 PyThreadState* __tstate = wxPyBeginAllowThreads();
23411 result = (char *)wxGetDefaultPyEncoding();
23412
23413 wxPyEndAllowThreads(__tstate);
23414 if (PyErr_Occurred()) SWIG_fail;
23415 }
23416 resultobj = SWIG_FromCharPtr(result);
23417 return resultobj;
23418 fail:
23419 return NULL;
23420 }
23421
23422
23423 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23424 PyObject *resultobj;
23425 wxEventLoop *result;
23426 char *kwnames[] = {
23427 NULL
23428 };
23429
23430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23431 {
23432 PyThreadState* __tstate = wxPyBeginAllowThreads();
23433 result = (wxEventLoop *)new wxEventLoop();
23434
23435 wxPyEndAllowThreads(__tstate);
23436 if (PyErr_Occurred()) SWIG_fail;
23437 }
23438 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23439 return resultobj;
23440 fail:
23441 return NULL;
23442 }
23443
23444
23445 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23446 PyObject *resultobj;
23447 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23448 PyObject * obj0 = 0 ;
23449 char *kwnames[] = {
23450 (char *) "self", NULL
23451 };
23452
23453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23455 if (SWIG_arg_fail(1)) SWIG_fail;
23456 {
23457 PyThreadState* __tstate = wxPyBeginAllowThreads();
23458 delete arg1;
23459
23460 wxPyEndAllowThreads(__tstate);
23461 if (PyErr_Occurred()) SWIG_fail;
23462 }
23463 Py_INCREF(Py_None); resultobj = Py_None;
23464 return resultobj;
23465 fail:
23466 return NULL;
23467 }
23468
23469
23470 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23471 PyObject *resultobj;
23472 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23473 int result;
23474 PyObject * obj0 = 0 ;
23475 char *kwnames[] = {
23476 (char *) "self", NULL
23477 };
23478
23479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
23480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23481 if (SWIG_arg_fail(1)) SWIG_fail;
23482 {
23483 PyThreadState* __tstate = wxPyBeginAllowThreads();
23484 result = (int)(arg1)->Run();
23485
23486 wxPyEndAllowThreads(__tstate);
23487 if (PyErr_Occurred()) SWIG_fail;
23488 }
23489 {
23490 resultobj = SWIG_From_int((int)(result));
23491 }
23492 return resultobj;
23493 fail:
23494 return NULL;
23495 }
23496
23497
23498 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23499 PyObject *resultobj;
23500 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23501 int arg2 = (int) 0 ;
23502 PyObject * obj0 = 0 ;
23503 PyObject * obj1 = 0 ;
23504 char *kwnames[] = {
23505 (char *) "self",(char *) "rc", NULL
23506 };
23507
23508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
23509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23510 if (SWIG_arg_fail(1)) SWIG_fail;
23511 if (obj1) {
23512 {
23513 arg2 = (int)(SWIG_As_int(obj1));
23514 if (SWIG_arg_fail(2)) SWIG_fail;
23515 }
23516 }
23517 {
23518 PyThreadState* __tstate = wxPyBeginAllowThreads();
23519 (arg1)->Exit(arg2);
23520
23521 wxPyEndAllowThreads(__tstate);
23522 if (PyErr_Occurred()) SWIG_fail;
23523 }
23524 Py_INCREF(Py_None); resultobj = Py_None;
23525 return resultobj;
23526 fail:
23527 return NULL;
23528 }
23529
23530
23531 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23532 PyObject *resultobj;
23533 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23534 bool result;
23535 PyObject * obj0 = 0 ;
23536 char *kwnames[] = {
23537 (char *) "self", NULL
23538 };
23539
23540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
23541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23542 if (SWIG_arg_fail(1)) SWIG_fail;
23543 {
23544 PyThreadState* __tstate = wxPyBeginAllowThreads();
23545 result = (bool)((wxEventLoop const *)arg1)->Pending();
23546
23547 wxPyEndAllowThreads(__tstate);
23548 if (PyErr_Occurred()) SWIG_fail;
23549 }
23550 {
23551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23552 }
23553 return resultobj;
23554 fail:
23555 return NULL;
23556 }
23557
23558
23559 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23560 PyObject *resultobj;
23561 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23562 bool result;
23563 PyObject * obj0 = 0 ;
23564 char *kwnames[] = {
23565 (char *) "self", NULL
23566 };
23567
23568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
23569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23570 if (SWIG_arg_fail(1)) SWIG_fail;
23571 {
23572 PyThreadState* __tstate = wxPyBeginAllowThreads();
23573 result = (bool)(arg1)->Dispatch();
23574
23575 wxPyEndAllowThreads(__tstate);
23576 if (PyErr_Occurred()) SWIG_fail;
23577 }
23578 {
23579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23580 }
23581 return resultobj;
23582 fail:
23583 return NULL;
23584 }
23585
23586
23587 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23588 PyObject *resultobj;
23589 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23590 bool result;
23591 PyObject * obj0 = 0 ;
23592 char *kwnames[] = {
23593 (char *) "self", NULL
23594 };
23595
23596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
23597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23598 if (SWIG_arg_fail(1)) SWIG_fail;
23599 {
23600 PyThreadState* __tstate = wxPyBeginAllowThreads();
23601 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
23602
23603 wxPyEndAllowThreads(__tstate);
23604 if (PyErr_Occurred()) SWIG_fail;
23605 }
23606 {
23607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23608 }
23609 return resultobj;
23610 fail:
23611 return NULL;
23612 }
23613
23614
23615 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23616 PyObject *resultobj;
23617 wxEventLoop *result;
23618 char *kwnames[] = {
23619 NULL
23620 };
23621
23622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
23623 {
23624 PyThreadState* __tstate = wxPyBeginAllowThreads();
23625 result = (wxEventLoop *)wxEventLoop::GetActive();
23626
23627 wxPyEndAllowThreads(__tstate);
23628 if (PyErr_Occurred()) SWIG_fail;
23629 }
23630 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
23631 return resultobj;
23632 fail:
23633 return NULL;
23634 }
23635
23636
23637 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23638 PyObject *resultobj;
23639 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23640 PyObject * obj0 = 0 ;
23641 char *kwnames[] = {
23642 (char *) "loop", NULL
23643 };
23644
23645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
23646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23647 if (SWIG_arg_fail(1)) SWIG_fail;
23648 {
23649 PyThreadState* __tstate = wxPyBeginAllowThreads();
23650 wxEventLoop::SetActive(arg1);
23651
23652 wxPyEndAllowThreads(__tstate);
23653 if (PyErr_Occurred()) SWIG_fail;
23654 }
23655 Py_INCREF(Py_None); resultobj = Py_None;
23656 return resultobj;
23657 fail:
23658 return NULL;
23659 }
23660
23661
23662 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
23663 PyObject *obj;
23664 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23665 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
23666 Py_INCREF(obj);
23667 return Py_BuildValue((char *)"");
23668 }
23669 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23670 PyObject *resultobj;
23671 int arg1 = (int) 0 ;
23672 int arg2 = (int) 0 ;
23673 int arg3 = (int) 0 ;
23674 wxAcceleratorEntry *result;
23675 PyObject * obj0 = 0 ;
23676 PyObject * obj1 = 0 ;
23677 PyObject * obj2 = 0 ;
23678 char *kwnames[] = {
23679 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
23680 };
23681
23682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
23683 if (obj0) {
23684 {
23685 arg1 = (int)(SWIG_As_int(obj0));
23686 if (SWIG_arg_fail(1)) SWIG_fail;
23687 }
23688 }
23689 if (obj1) {
23690 {
23691 arg2 = (int)(SWIG_As_int(obj1));
23692 if (SWIG_arg_fail(2)) SWIG_fail;
23693 }
23694 }
23695 if (obj2) {
23696 {
23697 arg3 = (int)(SWIG_As_int(obj2));
23698 if (SWIG_arg_fail(3)) SWIG_fail;
23699 }
23700 }
23701 {
23702 PyThreadState* __tstate = wxPyBeginAllowThreads();
23703 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
23704
23705 wxPyEndAllowThreads(__tstate);
23706 if (PyErr_Occurred()) SWIG_fail;
23707 }
23708 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
23709 return resultobj;
23710 fail:
23711 return NULL;
23712 }
23713
23714
23715 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23716 PyObject *resultobj;
23717 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23718 PyObject * obj0 = 0 ;
23719 char *kwnames[] = {
23720 (char *) "self", NULL
23721 };
23722
23723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
23724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23725 if (SWIG_arg_fail(1)) SWIG_fail;
23726 {
23727 PyThreadState* __tstate = wxPyBeginAllowThreads();
23728 delete arg1;
23729
23730 wxPyEndAllowThreads(__tstate);
23731 if (PyErr_Occurred()) SWIG_fail;
23732 }
23733 Py_INCREF(Py_None); resultobj = Py_None;
23734 return resultobj;
23735 fail:
23736 return NULL;
23737 }
23738
23739
23740 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
23741 PyObject *resultobj;
23742 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23743 int arg2 ;
23744 int arg3 ;
23745 int arg4 ;
23746 PyObject * obj0 = 0 ;
23747 PyObject * obj1 = 0 ;
23748 PyObject * obj2 = 0 ;
23749 PyObject * obj3 = 0 ;
23750 char *kwnames[] = {
23751 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
23752 };
23753
23754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23756 if (SWIG_arg_fail(1)) SWIG_fail;
23757 {
23758 arg2 = (int)(SWIG_As_int(obj1));
23759 if (SWIG_arg_fail(2)) SWIG_fail;
23760 }
23761 {
23762 arg3 = (int)(SWIG_As_int(obj2));
23763 if (SWIG_arg_fail(3)) SWIG_fail;
23764 }
23765 {
23766 arg4 = (int)(SWIG_As_int(obj3));
23767 if (SWIG_arg_fail(4)) SWIG_fail;
23768 }
23769 {
23770 PyThreadState* __tstate = wxPyBeginAllowThreads();
23771 (arg1)->Set(arg2,arg3,arg4);
23772
23773 wxPyEndAllowThreads(__tstate);
23774 if (PyErr_Occurred()) SWIG_fail;
23775 }
23776 Py_INCREF(Py_None); resultobj = Py_None;
23777 return resultobj;
23778 fail:
23779 return NULL;
23780 }
23781
23782
23783 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
23784 PyObject *resultobj;
23785 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23786 int result;
23787 PyObject * obj0 = 0 ;
23788 char *kwnames[] = {
23789 (char *) "self", NULL
23790 };
23791
23792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
23793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23794 if (SWIG_arg_fail(1)) SWIG_fail;
23795 {
23796 PyThreadState* __tstate = wxPyBeginAllowThreads();
23797 result = (int)(arg1)->GetFlags();
23798
23799 wxPyEndAllowThreads(__tstate);
23800 if (PyErr_Occurred()) SWIG_fail;
23801 }
23802 {
23803 resultobj = SWIG_From_int((int)(result));
23804 }
23805 return resultobj;
23806 fail:
23807 return NULL;
23808 }
23809
23810
23811 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
23812 PyObject *resultobj;
23813 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23814 int result;
23815 PyObject * obj0 = 0 ;
23816 char *kwnames[] = {
23817 (char *) "self", NULL
23818 };
23819
23820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
23821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23822 if (SWIG_arg_fail(1)) SWIG_fail;
23823 {
23824 PyThreadState* __tstate = wxPyBeginAllowThreads();
23825 result = (int)(arg1)->GetKeyCode();
23826
23827 wxPyEndAllowThreads(__tstate);
23828 if (PyErr_Occurred()) SWIG_fail;
23829 }
23830 {
23831 resultobj = SWIG_From_int((int)(result));
23832 }
23833 return resultobj;
23834 fail:
23835 return NULL;
23836 }
23837
23838
23839 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
23840 PyObject *resultobj;
23841 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23842 int result;
23843 PyObject * obj0 = 0 ;
23844 char *kwnames[] = {
23845 (char *) "self", NULL
23846 };
23847
23848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
23849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23850 if (SWIG_arg_fail(1)) SWIG_fail;
23851 {
23852 PyThreadState* __tstate = wxPyBeginAllowThreads();
23853 result = (int)(arg1)->GetCommand();
23854
23855 wxPyEndAllowThreads(__tstate);
23856 if (PyErr_Occurred()) SWIG_fail;
23857 }
23858 {
23859 resultobj = SWIG_From_int((int)(result));
23860 }
23861 return resultobj;
23862 fail:
23863 return NULL;
23864 }
23865
23866
23867 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
23868 PyObject *obj;
23869 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23870 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
23871 Py_INCREF(obj);
23872 return Py_BuildValue((char *)"");
23873 }
23874 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
23875 PyObject *resultobj;
23876 int arg1 ;
23877 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
23878 wxAcceleratorTable *result;
23879 PyObject * obj0 = 0 ;
23880 char *kwnames[] = {
23881 (char *) "n", NULL
23882 };
23883
23884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
23885 {
23886 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
23887 if (arg2) arg1 = PyList_Size(obj0);
23888 else arg1 = 0;
23889 }
23890 {
23891 PyThreadState* __tstate = wxPyBeginAllowThreads();
23892 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
23893
23894 wxPyEndAllowThreads(__tstate);
23895 if (PyErr_Occurred()) SWIG_fail;
23896 }
23897 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
23898 {
23899 delete [] arg2;
23900 }
23901 return resultobj;
23902 fail:
23903 {
23904 delete [] arg2;
23905 }
23906 return NULL;
23907 }
23908
23909
23910 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
23911 PyObject *resultobj;
23912 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
23913 PyObject * obj0 = 0 ;
23914 char *kwnames[] = {
23915 (char *) "self", NULL
23916 };
23917
23918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
23919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
23920 if (SWIG_arg_fail(1)) SWIG_fail;
23921 {
23922 PyThreadState* __tstate = wxPyBeginAllowThreads();
23923 delete arg1;
23924
23925 wxPyEndAllowThreads(__tstate);
23926 if (PyErr_Occurred()) SWIG_fail;
23927 }
23928 Py_INCREF(Py_None); resultobj = Py_None;
23929 return resultobj;
23930 fail:
23931 return NULL;
23932 }
23933
23934
23935 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
23936 PyObject *resultobj;
23937 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
23938 bool result;
23939 PyObject * obj0 = 0 ;
23940 char *kwnames[] = {
23941 (char *) "self", NULL
23942 };
23943
23944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
23945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
23946 if (SWIG_arg_fail(1)) SWIG_fail;
23947 {
23948 PyThreadState* __tstate = wxPyBeginAllowThreads();
23949 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
23950
23951 wxPyEndAllowThreads(__tstate);
23952 if (PyErr_Occurred()) SWIG_fail;
23953 }
23954 {
23955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23956 }
23957 return resultobj;
23958 fail:
23959 return NULL;
23960 }
23961
23962
23963 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
23964 PyObject *obj;
23965 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23966 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
23967 Py_INCREF(obj);
23968 return Py_BuildValue((char *)"");
23969 }
23970 static int _wrap_NullAcceleratorTable_set(PyObject *) {
23971 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
23972 return 1;
23973 }
23974
23975
23976 static PyObject *_wrap_NullAcceleratorTable_get(void) {
23977 PyObject *pyobj;
23978
23979 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
23980 return pyobj;
23981 }
23982
23983
23984 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
23985 PyObject *resultobj;
23986 wxString *arg1 = 0 ;
23987 wxAcceleratorEntry *result;
23988 bool temp1 = false ;
23989 PyObject * obj0 = 0 ;
23990 char *kwnames[] = {
23991 (char *) "label", NULL
23992 };
23993
23994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
23995 {
23996 arg1 = wxString_in_helper(obj0);
23997 if (arg1 == NULL) SWIG_fail;
23998 temp1 = true;
23999 }
24000 {
24001 PyThreadState* __tstate = wxPyBeginAllowThreads();
24002 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24003
24004 wxPyEndAllowThreads(__tstate);
24005 if (PyErr_Occurred()) SWIG_fail;
24006 }
24007 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24008 {
24009 if (temp1)
24010 delete arg1;
24011 }
24012 return resultobj;
24013 fail:
24014 {
24015 if (temp1)
24016 delete arg1;
24017 }
24018 return NULL;
24019 }
24020
24021
24022 static int _wrap_PanelNameStr_set(PyObject *) {
24023 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24024 return 1;
24025 }
24026
24027
24028 static PyObject *_wrap_PanelNameStr_get(void) {
24029 PyObject *pyobj;
24030
24031 {
24032 #if wxUSE_UNICODE
24033 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24034 #else
24035 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24036 #endif
24037 }
24038 return pyobj;
24039 }
24040
24041
24042 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24043 PyObject *resultobj;
24044 wxVisualAttributes *result;
24045 char *kwnames[] = {
24046 NULL
24047 };
24048
24049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24050 {
24051 PyThreadState* __tstate = wxPyBeginAllowThreads();
24052 result = (wxVisualAttributes *)new_wxVisualAttributes();
24053
24054 wxPyEndAllowThreads(__tstate);
24055 if (PyErr_Occurred()) SWIG_fail;
24056 }
24057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24058 return resultobj;
24059 fail:
24060 return NULL;
24061 }
24062
24063
24064 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24065 PyObject *resultobj;
24066 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24067 PyObject * obj0 = 0 ;
24068 char *kwnames[] = {
24069 (char *) "self", NULL
24070 };
24071
24072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24074 if (SWIG_arg_fail(1)) SWIG_fail;
24075 {
24076 PyThreadState* __tstate = wxPyBeginAllowThreads();
24077 delete_wxVisualAttributes(arg1);
24078
24079 wxPyEndAllowThreads(__tstate);
24080 if (PyErr_Occurred()) SWIG_fail;
24081 }
24082 Py_INCREF(Py_None); resultobj = Py_None;
24083 return resultobj;
24084 fail:
24085 return NULL;
24086 }
24087
24088
24089 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24090 PyObject *resultobj;
24091 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24092 wxFont *arg2 = (wxFont *) 0 ;
24093 PyObject * obj0 = 0 ;
24094 PyObject * obj1 = 0 ;
24095 char *kwnames[] = {
24096 (char *) "self",(char *) "font", NULL
24097 };
24098
24099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24101 if (SWIG_arg_fail(1)) SWIG_fail;
24102 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24103 if (SWIG_arg_fail(2)) SWIG_fail;
24104 if (arg1) (arg1)->font = *arg2;
24105
24106 Py_INCREF(Py_None); resultobj = Py_None;
24107 return resultobj;
24108 fail:
24109 return NULL;
24110 }
24111
24112
24113 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24114 PyObject *resultobj;
24115 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24116 wxFont *result;
24117 PyObject * obj0 = 0 ;
24118 char *kwnames[] = {
24119 (char *) "self", NULL
24120 };
24121
24122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24124 if (SWIG_arg_fail(1)) SWIG_fail;
24125 result = (wxFont *)& ((arg1)->font);
24126
24127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24128 return resultobj;
24129 fail:
24130 return NULL;
24131 }
24132
24133
24134 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24135 PyObject *resultobj;
24136 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24137 wxColour *arg2 = (wxColour *) 0 ;
24138 PyObject * obj0 = 0 ;
24139 PyObject * obj1 = 0 ;
24140 char *kwnames[] = {
24141 (char *) "self",(char *) "colFg", NULL
24142 };
24143
24144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24146 if (SWIG_arg_fail(1)) SWIG_fail;
24147 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24148 if (SWIG_arg_fail(2)) SWIG_fail;
24149 if (arg1) (arg1)->colFg = *arg2;
24150
24151 Py_INCREF(Py_None); resultobj = Py_None;
24152 return resultobj;
24153 fail:
24154 return NULL;
24155 }
24156
24157
24158 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24159 PyObject *resultobj;
24160 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24161 wxColour *result;
24162 PyObject * obj0 = 0 ;
24163 char *kwnames[] = {
24164 (char *) "self", NULL
24165 };
24166
24167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24169 if (SWIG_arg_fail(1)) SWIG_fail;
24170 result = (wxColour *)& ((arg1)->colFg);
24171
24172 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24173 return resultobj;
24174 fail:
24175 return NULL;
24176 }
24177
24178
24179 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24180 PyObject *resultobj;
24181 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24182 wxColour *arg2 = (wxColour *) 0 ;
24183 PyObject * obj0 = 0 ;
24184 PyObject * obj1 = 0 ;
24185 char *kwnames[] = {
24186 (char *) "self",(char *) "colBg", NULL
24187 };
24188
24189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24191 if (SWIG_arg_fail(1)) SWIG_fail;
24192 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24193 if (SWIG_arg_fail(2)) SWIG_fail;
24194 if (arg1) (arg1)->colBg = *arg2;
24195
24196 Py_INCREF(Py_None); resultobj = Py_None;
24197 return resultobj;
24198 fail:
24199 return NULL;
24200 }
24201
24202
24203 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24204 PyObject *resultobj;
24205 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24206 wxColour *result;
24207 PyObject * obj0 = 0 ;
24208 char *kwnames[] = {
24209 (char *) "self", NULL
24210 };
24211
24212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24214 if (SWIG_arg_fail(1)) SWIG_fail;
24215 result = (wxColour *)& ((arg1)->colBg);
24216
24217 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24218 return resultobj;
24219 fail:
24220 return NULL;
24221 }
24222
24223
24224 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24225 PyObject *obj;
24226 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24227 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24228 Py_INCREF(obj);
24229 return Py_BuildValue((char *)"");
24230 }
24231 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24232 PyObject *resultobj;
24233 wxWindow *arg1 = (wxWindow *) 0 ;
24234 int arg2 = (int) (int)-1 ;
24235 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24236 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24237 wxSize const &arg4_defvalue = wxDefaultSize ;
24238 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24239 long arg5 = (long) 0 ;
24240 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24241 wxString *arg6 = (wxString *) &arg6_defvalue ;
24242 wxWindow *result;
24243 wxPoint temp3 ;
24244 wxSize temp4 ;
24245 bool temp6 = false ;
24246 PyObject * obj0 = 0 ;
24247 PyObject * obj1 = 0 ;
24248 PyObject * obj2 = 0 ;
24249 PyObject * obj3 = 0 ;
24250 PyObject * obj4 = 0 ;
24251 PyObject * obj5 = 0 ;
24252 char *kwnames[] = {
24253 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24254 };
24255
24256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24258 if (SWIG_arg_fail(1)) SWIG_fail;
24259 if (obj1) {
24260 {
24261 arg2 = (int const)(SWIG_As_int(obj1));
24262 if (SWIG_arg_fail(2)) SWIG_fail;
24263 }
24264 }
24265 if (obj2) {
24266 {
24267 arg3 = &temp3;
24268 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24269 }
24270 }
24271 if (obj3) {
24272 {
24273 arg4 = &temp4;
24274 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24275 }
24276 }
24277 if (obj4) {
24278 {
24279 arg5 = (long)(SWIG_As_long(obj4));
24280 if (SWIG_arg_fail(5)) SWIG_fail;
24281 }
24282 }
24283 if (obj5) {
24284 {
24285 arg6 = wxString_in_helper(obj5);
24286 if (arg6 == NULL) SWIG_fail;
24287 temp6 = true;
24288 }
24289 }
24290 {
24291 if (!wxPyCheckForApp()) SWIG_fail;
24292 PyThreadState* __tstate = wxPyBeginAllowThreads();
24293 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24294
24295 wxPyEndAllowThreads(__tstate);
24296 if (PyErr_Occurred()) SWIG_fail;
24297 }
24298 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24299 {
24300 if (temp6)
24301 delete arg6;
24302 }
24303 return resultobj;
24304 fail:
24305 {
24306 if (temp6)
24307 delete arg6;
24308 }
24309 return NULL;
24310 }
24311
24312
24313 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24314 PyObject *resultobj;
24315 wxWindow *result;
24316 char *kwnames[] = {
24317 NULL
24318 };
24319
24320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24321 {
24322 if (!wxPyCheckForApp()) SWIG_fail;
24323 PyThreadState* __tstate = wxPyBeginAllowThreads();
24324 result = (wxWindow *)new wxWindow();
24325
24326 wxPyEndAllowThreads(__tstate);
24327 if (PyErr_Occurred()) SWIG_fail;
24328 }
24329 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24330 return resultobj;
24331 fail:
24332 return NULL;
24333 }
24334
24335
24336 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24337 PyObject *resultobj;
24338 wxWindow *arg1 = (wxWindow *) 0 ;
24339 wxWindow *arg2 = (wxWindow *) 0 ;
24340 int arg3 = (int) (int)-1 ;
24341 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24342 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24343 wxSize const &arg5_defvalue = wxDefaultSize ;
24344 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24345 long arg6 = (long) 0 ;
24346 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24347 wxString *arg7 = (wxString *) &arg7_defvalue ;
24348 bool result;
24349 wxPoint temp4 ;
24350 wxSize temp5 ;
24351 bool temp7 = false ;
24352 PyObject * obj0 = 0 ;
24353 PyObject * obj1 = 0 ;
24354 PyObject * obj2 = 0 ;
24355 PyObject * obj3 = 0 ;
24356 PyObject * obj4 = 0 ;
24357 PyObject * obj5 = 0 ;
24358 PyObject * obj6 = 0 ;
24359 char *kwnames[] = {
24360 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24361 };
24362
24363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24365 if (SWIG_arg_fail(1)) SWIG_fail;
24366 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24367 if (SWIG_arg_fail(2)) SWIG_fail;
24368 if (obj2) {
24369 {
24370 arg3 = (int const)(SWIG_As_int(obj2));
24371 if (SWIG_arg_fail(3)) SWIG_fail;
24372 }
24373 }
24374 if (obj3) {
24375 {
24376 arg4 = &temp4;
24377 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24378 }
24379 }
24380 if (obj4) {
24381 {
24382 arg5 = &temp5;
24383 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24384 }
24385 }
24386 if (obj5) {
24387 {
24388 arg6 = (long)(SWIG_As_long(obj5));
24389 if (SWIG_arg_fail(6)) SWIG_fail;
24390 }
24391 }
24392 if (obj6) {
24393 {
24394 arg7 = wxString_in_helper(obj6);
24395 if (arg7 == NULL) SWIG_fail;
24396 temp7 = true;
24397 }
24398 }
24399 {
24400 PyThreadState* __tstate = wxPyBeginAllowThreads();
24401 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24402
24403 wxPyEndAllowThreads(__tstate);
24404 if (PyErr_Occurred()) SWIG_fail;
24405 }
24406 {
24407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24408 }
24409 {
24410 if (temp7)
24411 delete arg7;
24412 }
24413 return resultobj;
24414 fail:
24415 {
24416 if (temp7)
24417 delete arg7;
24418 }
24419 return NULL;
24420 }
24421
24422
24423 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24424 PyObject *resultobj;
24425 wxWindow *arg1 = (wxWindow *) 0 ;
24426 bool arg2 = (bool) false ;
24427 bool result;
24428 PyObject * obj0 = 0 ;
24429 PyObject * obj1 = 0 ;
24430 char *kwnames[] = {
24431 (char *) "self",(char *) "force", NULL
24432 };
24433
24434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24436 if (SWIG_arg_fail(1)) SWIG_fail;
24437 if (obj1) {
24438 {
24439 arg2 = (bool)(SWIG_As_bool(obj1));
24440 if (SWIG_arg_fail(2)) SWIG_fail;
24441 }
24442 }
24443 {
24444 PyThreadState* __tstate = wxPyBeginAllowThreads();
24445 result = (bool)(arg1)->Close(arg2);
24446
24447 wxPyEndAllowThreads(__tstate);
24448 if (PyErr_Occurred()) SWIG_fail;
24449 }
24450 {
24451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24452 }
24453 return resultobj;
24454 fail:
24455 return NULL;
24456 }
24457
24458
24459 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24460 PyObject *resultobj;
24461 wxWindow *arg1 = (wxWindow *) 0 ;
24462 bool result;
24463 PyObject * obj0 = 0 ;
24464 char *kwnames[] = {
24465 (char *) "self", NULL
24466 };
24467
24468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24470 if (SWIG_arg_fail(1)) SWIG_fail;
24471 {
24472 PyThreadState* __tstate = wxPyBeginAllowThreads();
24473 result = (bool)(arg1)->Destroy();
24474
24475 wxPyEndAllowThreads(__tstate);
24476 if (PyErr_Occurred()) SWIG_fail;
24477 }
24478 {
24479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24480 }
24481 return resultobj;
24482 fail:
24483 return NULL;
24484 }
24485
24486
24487 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
24488 PyObject *resultobj;
24489 wxWindow *arg1 = (wxWindow *) 0 ;
24490 bool result;
24491 PyObject * obj0 = 0 ;
24492 char *kwnames[] = {
24493 (char *) "self", NULL
24494 };
24495
24496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
24497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24498 if (SWIG_arg_fail(1)) SWIG_fail;
24499 {
24500 PyThreadState* __tstate = wxPyBeginAllowThreads();
24501 result = (bool)(arg1)->DestroyChildren();
24502
24503 wxPyEndAllowThreads(__tstate);
24504 if (PyErr_Occurred()) SWIG_fail;
24505 }
24506 {
24507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24508 }
24509 return resultobj;
24510 fail:
24511 return NULL;
24512 }
24513
24514
24515 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
24516 PyObject *resultobj;
24517 wxWindow *arg1 = (wxWindow *) 0 ;
24518 bool result;
24519 PyObject * obj0 = 0 ;
24520 char *kwnames[] = {
24521 (char *) "self", NULL
24522 };
24523
24524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
24525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24526 if (SWIG_arg_fail(1)) SWIG_fail;
24527 {
24528 PyThreadState* __tstate = wxPyBeginAllowThreads();
24529 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
24530
24531 wxPyEndAllowThreads(__tstate);
24532 if (PyErr_Occurred()) SWIG_fail;
24533 }
24534 {
24535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24536 }
24537 return resultobj;
24538 fail:
24539 return NULL;
24540 }
24541
24542
24543 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24544 PyObject *resultobj;
24545 wxWindow *arg1 = (wxWindow *) 0 ;
24546 wxString *arg2 = 0 ;
24547 bool temp2 = false ;
24548 PyObject * obj0 = 0 ;
24549 PyObject * obj1 = 0 ;
24550 char *kwnames[] = {
24551 (char *) "self",(char *) "title", NULL
24552 };
24553
24554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
24555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24556 if (SWIG_arg_fail(1)) SWIG_fail;
24557 {
24558 arg2 = wxString_in_helper(obj1);
24559 if (arg2 == NULL) SWIG_fail;
24560 temp2 = true;
24561 }
24562 {
24563 PyThreadState* __tstate = wxPyBeginAllowThreads();
24564 (arg1)->SetTitle((wxString const &)*arg2);
24565
24566 wxPyEndAllowThreads(__tstate);
24567 if (PyErr_Occurred()) SWIG_fail;
24568 }
24569 Py_INCREF(Py_None); resultobj = Py_None;
24570 {
24571 if (temp2)
24572 delete arg2;
24573 }
24574 return resultobj;
24575 fail:
24576 {
24577 if (temp2)
24578 delete arg2;
24579 }
24580 return NULL;
24581 }
24582
24583
24584 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24585 PyObject *resultobj;
24586 wxWindow *arg1 = (wxWindow *) 0 ;
24587 wxString result;
24588 PyObject * obj0 = 0 ;
24589 char *kwnames[] = {
24590 (char *) "self", NULL
24591 };
24592
24593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
24594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24595 if (SWIG_arg_fail(1)) SWIG_fail;
24596 {
24597 PyThreadState* __tstate = wxPyBeginAllowThreads();
24598 result = ((wxWindow const *)arg1)->GetTitle();
24599
24600 wxPyEndAllowThreads(__tstate);
24601 if (PyErr_Occurred()) SWIG_fail;
24602 }
24603 {
24604 #if wxUSE_UNICODE
24605 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24606 #else
24607 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24608 #endif
24609 }
24610 return resultobj;
24611 fail:
24612 return NULL;
24613 }
24614
24615
24616 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24617 PyObject *resultobj;
24618 wxWindow *arg1 = (wxWindow *) 0 ;
24619 wxString *arg2 = 0 ;
24620 bool temp2 = false ;
24621 PyObject * obj0 = 0 ;
24622 PyObject * obj1 = 0 ;
24623 char *kwnames[] = {
24624 (char *) "self",(char *) "label", NULL
24625 };
24626
24627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
24628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24629 if (SWIG_arg_fail(1)) SWIG_fail;
24630 {
24631 arg2 = wxString_in_helper(obj1);
24632 if (arg2 == NULL) SWIG_fail;
24633 temp2 = true;
24634 }
24635 {
24636 PyThreadState* __tstate = wxPyBeginAllowThreads();
24637 (arg1)->SetLabel((wxString const &)*arg2);
24638
24639 wxPyEndAllowThreads(__tstate);
24640 if (PyErr_Occurred()) SWIG_fail;
24641 }
24642 Py_INCREF(Py_None); resultobj = Py_None;
24643 {
24644 if (temp2)
24645 delete arg2;
24646 }
24647 return resultobj;
24648 fail:
24649 {
24650 if (temp2)
24651 delete arg2;
24652 }
24653 return NULL;
24654 }
24655
24656
24657 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24658 PyObject *resultobj;
24659 wxWindow *arg1 = (wxWindow *) 0 ;
24660 wxString result;
24661 PyObject * obj0 = 0 ;
24662 char *kwnames[] = {
24663 (char *) "self", NULL
24664 };
24665
24666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
24667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24668 if (SWIG_arg_fail(1)) SWIG_fail;
24669 {
24670 PyThreadState* __tstate = wxPyBeginAllowThreads();
24671 result = ((wxWindow const *)arg1)->GetLabel();
24672
24673 wxPyEndAllowThreads(__tstate);
24674 if (PyErr_Occurred()) SWIG_fail;
24675 }
24676 {
24677 #if wxUSE_UNICODE
24678 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24679 #else
24680 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24681 #endif
24682 }
24683 return resultobj;
24684 fail:
24685 return NULL;
24686 }
24687
24688
24689 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
24690 PyObject *resultobj;
24691 wxWindow *arg1 = (wxWindow *) 0 ;
24692 wxString *arg2 = 0 ;
24693 bool temp2 = false ;
24694 PyObject * obj0 = 0 ;
24695 PyObject * obj1 = 0 ;
24696 char *kwnames[] = {
24697 (char *) "self",(char *) "name", NULL
24698 };
24699
24700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
24701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24702 if (SWIG_arg_fail(1)) SWIG_fail;
24703 {
24704 arg2 = wxString_in_helper(obj1);
24705 if (arg2 == NULL) SWIG_fail;
24706 temp2 = true;
24707 }
24708 {
24709 PyThreadState* __tstate = wxPyBeginAllowThreads();
24710 (arg1)->SetName((wxString const &)*arg2);
24711
24712 wxPyEndAllowThreads(__tstate);
24713 if (PyErr_Occurred()) SWIG_fail;
24714 }
24715 Py_INCREF(Py_None); resultobj = Py_None;
24716 {
24717 if (temp2)
24718 delete arg2;
24719 }
24720 return resultobj;
24721 fail:
24722 {
24723 if (temp2)
24724 delete arg2;
24725 }
24726 return NULL;
24727 }
24728
24729
24730 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
24731 PyObject *resultobj;
24732 wxWindow *arg1 = (wxWindow *) 0 ;
24733 wxString result;
24734 PyObject * obj0 = 0 ;
24735 char *kwnames[] = {
24736 (char *) "self", NULL
24737 };
24738
24739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
24740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24741 if (SWIG_arg_fail(1)) SWIG_fail;
24742 {
24743 PyThreadState* __tstate = wxPyBeginAllowThreads();
24744 result = ((wxWindow const *)arg1)->GetName();
24745
24746 wxPyEndAllowThreads(__tstate);
24747 if (PyErr_Occurred()) SWIG_fail;
24748 }
24749 {
24750 #if wxUSE_UNICODE
24751 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24752 #else
24753 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24754 #endif
24755 }
24756 return resultobj;
24757 fail:
24758 return NULL;
24759 }
24760
24761
24762 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
24763 PyObject *resultobj;
24764 wxWindow *arg1 = (wxWindow *) 0 ;
24765 wxWindowVariant arg2 ;
24766 PyObject * obj0 = 0 ;
24767 PyObject * obj1 = 0 ;
24768 char *kwnames[] = {
24769 (char *) "self",(char *) "variant", NULL
24770 };
24771
24772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
24773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24774 if (SWIG_arg_fail(1)) SWIG_fail;
24775 {
24776 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
24777 if (SWIG_arg_fail(2)) SWIG_fail;
24778 }
24779 {
24780 PyThreadState* __tstate = wxPyBeginAllowThreads();
24781 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
24782
24783 wxPyEndAllowThreads(__tstate);
24784 if (PyErr_Occurred()) SWIG_fail;
24785 }
24786 Py_INCREF(Py_None); resultobj = Py_None;
24787 return resultobj;
24788 fail:
24789 return NULL;
24790 }
24791
24792
24793 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
24794 PyObject *resultobj;
24795 wxWindow *arg1 = (wxWindow *) 0 ;
24796 wxWindowVariant result;
24797 PyObject * obj0 = 0 ;
24798 char *kwnames[] = {
24799 (char *) "self", NULL
24800 };
24801
24802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
24803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24804 if (SWIG_arg_fail(1)) SWIG_fail;
24805 {
24806 PyThreadState* __tstate = wxPyBeginAllowThreads();
24807 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
24808
24809 wxPyEndAllowThreads(__tstate);
24810 if (PyErr_Occurred()) SWIG_fail;
24811 }
24812 resultobj = SWIG_From_int((result));
24813 return resultobj;
24814 fail:
24815 return NULL;
24816 }
24817
24818
24819 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
24820 PyObject *resultobj;
24821 wxWindow *arg1 = (wxWindow *) 0 ;
24822 int arg2 ;
24823 PyObject * obj0 = 0 ;
24824 PyObject * obj1 = 0 ;
24825 char *kwnames[] = {
24826 (char *) "self",(char *) "winid", NULL
24827 };
24828
24829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
24830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24831 if (SWIG_arg_fail(1)) SWIG_fail;
24832 {
24833 arg2 = (int)(SWIG_As_int(obj1));
24834 if (SWIG_arg_fail(2)) SWIG_fail;
24835 }
24836 {
24837 PyThreadState* __tstate = wxPyBeginAllowThreads();
24838 (arg1)->SetId(arg2);
24839
24840 wxPyEndAllowThreads(__tstate);
24841 if (PyErr_Occurred()) SWIG_fail;
24842 }
24843 Py_INCREF(Py_None); resultobj = Py_None;
24844 return resultobj;
24845 fail:
24846 return NULL;
24847 }
24848
24849
24850 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
24851 PyObject *resultobj;
24852 wxWindow *arg1 = (wxWindow *) 0 ;
24853 int result;
24854 PyObject * obj0 = 0 ;
24855 char *kwnames[] = {
24856 (char *) "self", NULL
24857 };
24858
24859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
24860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24861 if (SWIG_arg_fail(1)) SWIG_fail;
24862 {
24863 PyThreadState* __tstate = wxPyBeginAllowThreads();
24864 result = (int)((wxWindow const *)arg1)->GetId();
24865
24866 wxPyEndAllowThreads(__tstate);
24867 if (PyErr_Occurred()) SWIG_fail;
24868 }
24869 {
24870 resultobj = SWIG_From_int((int)(result));
24871 }
24872 return resultobj;
24873 fail:
24874 return NULL;
24875 }
24876
24877
24878 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24879 PyObject *resultobj;
24880 int result;
24881 char *kwnames[] = {
24882 NULL
24883 };
24884
24885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
24886 {
24887 PyThreadState* __tstate = wxPyBeginAllowThreads();
24888 result = (int)wxWindow::NewControlId();
24889
24890 wxPyEndAllowThreads(__tstate);
24891 if (PyErr_Occurred()) SWIG_fail;
24892 }
24893 {
24894 resultobj = SWIG_From_int((int)(result));
24895 }
24896 return resultobj;
24897 fail:
24898 return NULL;
24899 }
24900
24901
24902 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24903 PyObject *resultobj;
24904 int arg1 ;
24905 int result;
24906 PyObject * obj0 = 0 ;
24907 char *kwnames[] = {
24908 (char *) "winid", NULL
24909 };
24910
24911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
24912 {
24913 arg1 = (int)(SWIG_As_int(obj0));
24914 if (SWIG_arg_fail(1)) SWIG_fail;
24915 }
24916 {
24917 PyThreadState* __tstate = wxPyBeginAllowThreads();
24918 result = (int)wxWindow::NextControlId(arg1);
24919
24920 wxPyEndAllowThreads(__tstate);
24921 if (PyErr_Occurred()) SWIG_fail;
24922 }
24923 {
24924 resultobj = SWIG_From_int((int)(result));
24925 }
24926 return resultobj;
24927 fail:
24928 return NULL;
24929 }
24930
24931
24932 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24933 PyObject *resultobj;
24934 int arg1 ;
24935 int result;
24936 PyObject * obj0 = 0 ;
24937 char *kwnames[] = {
24938 (char *) "winid", NULL
24939 };
24940
24941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
24942 {
24943 arg1 = (int)(SWIG_As_int(obj0));
24944 if (SWIG_arg_fail(1)) SWIG_fail;
24945 }
24946 {
24947 PyThreadState* __tstate = wxPyBeginAllowThreads();
24948 result = (int)wxWindow::PrevControlId(arg1);
24949
24950 wxPyEndAllowThreads(__tstate);
24951 if (PyErr_Occurred()) SWIG_fail;
24952 }
24953 {
24954 resultobj = SWIG_From_int((int)(result));
24955 }
24956 return resultobj;
24957 fail:
24958 return NULL;
24959 }
24960
24961
24962 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
24963 PyObject *resultobj;
24964 wxWindow *arg1 = (wxWindow *) 0 ;
24965 wxSize *arg2 = 0 ;
24966 wxSize temp2 ;
24967 PyObject * obj0 = 0 ;
24968 PyObject * obj1 = 0 ;
24969 char *kwnames[] = {
24970 (char *) "self",(char *) "size", NULL
24971 };
24972
24973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
24974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24975 if (SWIG_arg_fail(1)) SWIG_fail;
24976 {
24977 arg2 = &temp2;
24978 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
24979 }
24980 {
24981 PyThreadState* __tstate = wxPyBeginAllowThreads();
24982 (arg1)->SetSize((wxSize const &)*arg2);
24983
24984 wxPyEndAllowThreads(__tstate);
24985 if (PyErr_Occurred()) SWIG_fail;
24986 }
24987 Py_INCREF(Py_None); resultobj = Py_None;
24988 return resultobj;
24989 fail:
24990 return NULL;
24991 }
24992
24993
24994 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
24995 PyObject *resultobj;
24996 wxWindow *arg1 = (wxWindow *) 0 ;
24997 int arg2 ;
24998 int arg3 ;
24999 int arg4 ;
25000 int arg5 ;
25001 int arg6 = (int) wxSIZE_AUTO ;
25002 PyObject * obj0 = 0 ;
25003 PyObject * obj1 = 0 ;
25004 PyObject * obj2 = 0 ;
25005 PyObject * obj3 = 0 ;
25006 PyObject * obj4 = 0 ;
25007 PyObject * obj5 = 0 ;
25008 char *kwnames[] = {
25009 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25010 };
25011
25012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25014 if (SWIG_arg_fail(1)) SWIG_fail;
25015 {
25016 arg2 = (int)(SWIG_As_int(obj1));
25017 if (SWIG_arg_fail(2)) SWIG_fail;
25018 }
25019 {
25020 arg3 = (int)(SWIG_As_int(obj2));
25021 if (SWIG_arg_fail(3)) SWIG_fail;
25022 }
25023 {
25024 arg4 = (int)(SWIG_As_int(obj3));
25025 if (SWIG_arg_fail(4)) SWIG_fail;
25026 }
25027 {
25028 arg5 = (int)(SWIG_As_int(obj4));
25029 if (SWIG_arg_fail(5)) SWIG_fail;
25030 }
25031 if (obj5) {
25032 {
25033 arg6 = (int)(SWIG_As_int(obj5));
25034 if (SWIG_arg_fail(6)) SWIG_fail;
25035 }
25036 }
25037 {
25038 PyThreadState* __tstate = wxPyBeginAllowThreads();
25039 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25040
25041 wxPyEndAllowThreads(__tstate);
25042 if (PyErr_Occurred()) SWIG_fail;
25043 }
25044 Py_INCREF(Py_None); resultobj = Py_None;
25045 return resultobj;
25046 fail:
25047 return NULL;
25048 }
25049
25050
25051 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25052 PyObject *resultobj;
25053 wxWindow *arg1 = (wxWindow *) 0 ;
25054 wxRect *arg2 = 0 ;
25055 int arg3 = (int) wxSIZE_AUTO ;
25056 wxRect temp2 ;
25057 PyObject * obj0 = 0 ;
25058 PyObject * obj1 = 0 ;
25059 PyObject * obj2 = 0 ;
25060 char *kwnames[] = {
25061 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25062 };
25063
25064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25066 if (SWIG_arg_fail(1)) SWIG_fail;
25067 {
25068 arg2 = &temp2;
25069 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25070 }
25071 if (obj2) {
25072 {
25073 arg3 = (int)(SWIG_As_int(obj2));
25074 if (SWIG_arg_fail(3)) SWIG_fail;
25075 }
25076 }
25077 {
25078 PyThreadState* __tstate = wxPyBeginAllowThreads();
25079 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25080
25081 wxPyEndAllowThreads(__tstate);
25082 if (PyErr_Occurred()) SWIG_fail;
25083 }
25084 Py_INCREF(Py_None); resultobj = Py_None;
25085 return resultobj;
25086 fail:
25087 return NULL;
25088 }
25089
25090
25091 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25092 PyObject *resultobj;
25093 wxWindow *arg1 = (wxWindow *) 0 ;
25094 int arg2 ;
25095 int arg3 ;
25096 PyObject * obj0 = 0 ;
25097 PyObject * obj1 = 0 ;
25098 PyObject * obj2 = 0 ;
25099 char *kwnames[] = {
25100 (char *) "self",(char *) "width",(char *) "height", NULL
25101 };
25102
25103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25105 if (SWIG_arg_fail(1)) SWIG_fail;
25106 {
25107 arg2 = (int)(SWIG_As_int(obj1));
25108 if (SWIG_arg_fail(2)) SWIG_fail;
25109 }
25110 {
25111 arg3 = (int)(SWIG_As_int(obj2));
25112 if (SWIG_arg_fail(3)) SWIG_fail;
25113 }
25114 {
25115 PyThreadState* __tstate = wxPyBeginAllowThreads();
25116 (arg1)->SetSize(arg2,arg3);
25117
25118 wxPyEndAllowThreads(__tstate);
25119 if (PyErr_Occurred()) SWIG_fail;
25120 }
25121 Py_INCREF(Py_None); resultobj = Py_None;
25122 return resultobj;
25123 fail:
25124 return NULL;
25125 }
25126
25127
25128 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25129 PyObject *resultobj;
25130 wxWindow *arg1 = (wxWindow *) 0 ;
25131 wxPoint *arg2 = 0 ;
25132 int arg3 = (int) wxSIZE_USE_EXISTING ;
25133 wxPoint temp2 ;
25134 PyObject * obj0 = 0 ;
25135 PyObject * obj1 = 0 ;
25136 PyObject * obj2 = 0 ;
25137 char *kwnames[] = {
25138 (char *) "self",(char *) "pt",(char *) "flags", NULL
25139 };
25140
25141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25143 if (SWIG_arg_fail(1)) SWIG_fail;
25144 {
25145 arg2 = &temp2;
25146 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25147 }
25148 if (obj2) {
25149 {
25150 arg3 = (int)(SWIG_As_int(obj2));
25151 if (SWIG_arg_fail(3)) SWIG_fail;
25152 }
25153 }
25154 {
25155 PyThreadState* __tstate = wxPyBeginAllowThreads();
25156 (arg1)->Move((wxPoint const &)*arg2,arg3);
25157
25158 wxPyEndAllowThreads(__tstate);
25159 if (PyErr_Occurred()) SWIG_fail;
25160 }
25161 Py_INCREF(Py_None); resultobj = Py_None;
25162 return resultobj;
25163 fail:
25164 return NULL;
25165 }
25166
25167
25168 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25169 PyObject *resultobj;
25170 wxWindow *arg1 = (wxWindow *) 0 ;
25171 int arg2 ;
25172 int arg3 ;
25173 int arg4 = (int) wxSIZE_USE_EXISTING ;
25174 PyObject * obj0 = 0 ;
25175 PyObject * obj1 = 0 ;
25176 PyObject * obj2 = 0 ;
25177 PyObject * obj3 = 0 ;
25178 char *kwnames[] = {
25179 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25180 };
25181
25182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25184 if (SWIG_arg_fail(1)) SWIG_fail;
25185 {
25186 arg2 = (int)(SWIG_As_int(obj1));
25187 if (SWIG_arg_fail(2)) SWIG_fail;
25188 }
25189 {
25190 arg3 = (int)(SWIG_As_int(obj2));
25191 if (SWIG_arg_fail(3)) SWIG_fail;
25192 }
25193 if (obj3) {
25194 {
25195 arg4 = (int)(SWIG_As_int(obj3));
25196 if (SWIG_arg_fail(4)) SWIG_fail;
25197 }
25198 }
25199 {
25200 PyThreadState* __tstate = wxPyBeginAllowThreads();
25201 (arg1)->Move(arg2,arg3,arg4);
25202
25203 wxPyEndAllowThreads(__tstate);
25204 if (PyErr_Occurred()) SWIG_fail;
25205 }
25206 Py_INCREF(Py_None); resultobj = Py_None;
25207 return resultobj;
25208 fail:
25209 return NULL;
25210 }
25211
25212
25213 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25214 PyObject *resultobj;
25215 wxWindow *arg1 = (wxWindow *) 0 ;
25216 wxSize const &arg2_defvalue = wxDefaultSize ;
25217 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25218 wxSize temp2 ;
25219 PyObject * obj0 = 0 ;
25220 PyObject * obj1 = 0 ;
25221 char *kwnames[] = {
25222 (char *) "self",(char *) "size", NULL
25223 };
25224
25225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25227 if (SWIG_arg_fail(1)) SWIG_fail;
25228 if (obj1) {
25229 {
25230 arg2 = &temp2;
25231 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25232 }
25233 }
25234 {
25235 PyThreadState* __tstate = wxPyBeginAllowThreads();
25236 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25237
25238 wxPyEndAllowThreads(__tstate);
25239 if (PyErr_Occurred()) SWIG_fail;
25240 }
25241 Py_INCREF(Py_None); resultobj = Py_None;
25242 return resultobj;
25243 fail:
25244 return NULL;
25245 }
25246
25247
25248 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25249 PyObject *resultobj;
25250 wxWindow *arg1 = (wxWindow *) 0 ;
25251 PyObject * obj0 = 0 ;
25252 char *kwnames[] = {
25253 (char *) "self", NULL
25254 };
25255
25256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25258 if (SWIG_arg_fail(1)) SWIG_fail;
25259 {
25260 PyThreadState* __tstate = wxPyBeginAllowThreads();
25261 (arg1)->Raise();
25262
25263 wxPyEndAllowThreads(__tstate);
25264 if (PyErr_Occurred()) SWIG_fail;
25265 }
25266 Py_INCREF(Py_None); resultobj = Py_None;
25267 return resultobj;
25268 fail:
25269 return NULL;
25270 }
25271
25272
25273 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25274 PyObject *resultobj;
25275 wxWindow *arg1 = (wxWindow *) 0 ;
25276 PyObject * obj0 = 0 ;
25277 char *kwnames[] = {
25278 (char *) "self", NULL
25279 };
25280
25281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25283 if (SWIG_arg_fail(1)) SWIG_fail;
25284 {
25285 PyThreadState* __tstate = wxPyBeginAllowThreads();
25286 (arg1)->Lower();
25287
25288 wxPyEndAllowThreads(__tstate);
25289 if (PyErr_Occurred()) SWIG_fail;
25290 }
25291 Py_INCREF(Py_None); resultobj = Py_None;
25292 return resultobj;
25293 fail:
25294 return NULL;
25295 }
25296
25297
25298 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25299 PyObject *resultobj;
25300 wxWindow *arg1 = (wxWindow *) 0 ;
25301 wxSize *arg2 = 0 ;
25302 wxSize temp2 ;
25303 PyObject * obj0 = 0 ;
25304 PyObject * obj1 = 0 ;
25305 char *kwnames[] = {
25306 (char *) "self",(char *) "size", NULL
25307 };
25308
25309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25311 if (SWIG_arg_fail(1)) SWIG_fail;
25312 {
25313 arg2 = &temp2;
25314 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25315 }
25316 {
25317 PyThreadState* __tstate = wxPyBeginAllowThreads();
25318 (arg1)->SetClientSize((wxSize const &)*arg2);
25319
25320 wxPyEndAllowThreads(__tstate);
25321 if (PyErr_Occurred()) SWIG_fail;
25322 }
25323 Py_INCREF(Py_None); resultobj = Py_None;
25324 return resultobj;
25325 fail:
25326 return NULL;
25327 }
25328
25329
25330 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25331 PyObject *resultobj;
25332 wxWindow *arg1 = (wxWindow *) 0 ;
25333 int arg2 ;
25334 int arg3 ;
25335 PyObject * obj0 = 0 ;
25336 PyObject * obj1 = 0 ;
25337 PyObject * obj2 = 0 ;
25338 char *kwnames[] = {
25339 (char *) "self",(char *) "width",(char *) "height", NULL
25340 };
25341
25342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25344 if (SWIG_arg_fail(1)) SWIG_fail;
25345 {
25346 arg2 = (int)(SWIG_As_int(obj1));
25347 if (SWIG_arg_fail(2)) SWIG_fail;
25348 }
25349 {
25350 arg3 = (int)(SWIG_As_int(obj2));
25351 if (SWIG_arg_fail(3)) SWIG_fail;
25352 }
25353 {
25354 PyThreadState* __tstate = wxPyBeginAllowThreads();
25355 (arg1)->SetClientSize(arg2,arg3);
25356
25357 wxPyEndAllowThreads(__tstate);
25358 if (PyErr_Occurred()) SWIG_fail;
25359 }
25360 Py_INCREF(Py_None); resultobj = Py_None;
25361 return resultobj;
25362 fail:
25363 return NULL;
25364 }
25365
25366
25367 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25368 PyObject *resultobj;
25369 wxWindow *arg1 = (wxWindow *) 0 ;
25370 wxRect *arg2 = 0 ;
25371 wxRect temp2 ;
25372 PyObject * obj0 = 0 ;
25373 PyObject * obj1 = 0 ;
25374 char *kwnames[] = {
25375 (char *) "self",(char *) "rect", NULL
25376 };
25377
25378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25380 if (SWIG_arg_fail(1)) SWIG_fail;
25381 {
25382 arg2 = &temp2;
25383 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25384 }
25385 {
25386 PyThreadState* __tstate = wxPyBeginAllowThreads();
25387 (arg1)->SetClientSize((wxRect const &)*arg2);
25388
25389 wxPyEndAllowThreads(__tstate);
25390 if (PyErr_Occurred()) SWIG_fail;
25391 }
25392 Py_INCREF(Py_None); resultobj = Py_None;
25393 return resultobj;
25394 fail:
25395 return NULL;
25396 }
25397
25398
25399 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25400 PyObject *resultobj;
25401 wxWindow *arg1 = (wxWindow *) 0 ;
25402 wxPoint result;
25403 PyObject * obj0 = 0 ;
25404 char *kwnames[] = {
25405 (char *) "self", NULL
25406 };
25407
25408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
25409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25410 if (SWIG_arg_fail(1)) SWIG_fail;
25411 {
25412 PyThreadState* __tstate = wxPyBeginAllowThreads();
25413 result = (arg1)->GetPosition();
25414
25415 wxPyEndAllowThreads(__tstate);
25416 if (PyErr_Occurred()) SWIG_fail;
25417 }
25418 {
25419 wxPoint * resultptr;
25420 resultptr = new wxPoint((wxPoint &)(result));
25421 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25422 }
25423 return resultobj;
25424 fail:
25425 return NULL;
25426 }
25427
25428
25429 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25430 PyObject *resultobj;
25431 wxWindow *arg1 = (wxWindow *) 0 ;
25432 int *arg2 = (int *) 0 ;
25433 int *arg3 = (int *) 0 ;
25434 int temp2 ;
25435 int res2 = 0 ;
25436 int temp3 ;
25437 int res3 = 0 ;
25438 PyObject * obj0 = 0 ;
25439 char *kwnames[] = {
25440 (char *) "self", NULL
25441 };
25442
25443 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25444 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25447 if (SWIG_arg_fail(1)) SWIG_fail;
25448 {
25449 PyThreadState* __tstate = wxPyBeginAllowThreads();
25450 (arg1)->GetPosition(arg2,arg3);
25451
25452 wxPyEndAllowThreads(__tstate);
25453 if (PyErr_Occurred()) SWIG_fail;
25454 }
25455 Py_INCREF(Py_None); resultobj = Py_None;
25456 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25457 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25458 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25459 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25460 return resultobj;
25461 fail:
25462 return NULL;
25463 }
25464
25465
25466 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25467 PyObject *resultobj;
25468 wxWindow *arg1 = (wxWindow *) 0 ;
25469 wxSize result;
25470 PyObject * obj0 = 0 ;
25471 char *kwnames[] = {
25472 (char *) "self", NULL
25473 };
25474
25475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
25476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25477 if (SWIG_arg_fail(1)) SWIG_fail;
25478 {
25479 PyThreadState* __tstate = wxPyBeginAllowThreads();
25480 result = ((wxWindow const *)arg1)->GetSize();
25481
25482 wxPyEndAllowThreads(__tstate);
25483 if (PyErr_Occurred()) SWIG_fail;
25484 }
25485 {
25486 wxSize * resultptr;
25487 resultptr = new wxSize((wxSize &)(result));
25488 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25489 }
25490 return resultobj;
25491 fail:
25492 return NULL;
25493 }
25494
25495
25496 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25497 PyObject *resultobj;
25498 wxWindow *arg1 = (wxWindow *) 0 ;
25499 int *arg2 = (int *) 0 ;
25500 int *arg3 = (int *) 0 ;
25501 int temp2 ;
25502 int res2 = 0 ;
25503 int temp3 ;
25504 int res3 = 0 ;
25505 PyObject * obj0 = 0 ;
25506 char *kwnames[] = {
25507 (char *) "self", NULL
25508 };
25509
25510 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25511 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
25513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25514 if (SWIG_arg_fail(1)) SWIG_fail;
25515 {
25516 PyThreadState* __tstate = wxPyBeginAllowThreads();
25517 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
25518
25519 wxPyEndAllowThreads(__tstate);
25520 if (PyErr_Occurred()) SWIG_fail;
25521 }
25522 Py_INCREF(Py_None); resultobj = Py_None;
25523 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25524 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25525 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25526 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25527 return resultobj;
25528 fail:
25529 return NULL;
25530 }
25531
25532
25533 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25534 PyObject *resultobj;
25535 wxWindow *arg1 = (wxWindow *) 0 ;
25536 wxRect result;
25537 PyObject * obj0 = 0 ;
25538 char *kwnames[] = {
25539 (char *) "self", NULL
25540 };
25541
25542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
25543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25544 if (SWIG_arg_fail(1)) SWIG_fail;
25545 {
25546 PyThreadState* __tstate = wxPyBeginAllowThreads();
25547 result = ((wxWindow const *)arg1)->GetRect();
25548
25549 wxPyEndAllowThreads(__tstate);
25550 if (PyErr_Occurred()) SWIG_fail;
25551 }
25552 {
25553 wxRect * resultptr;
25554 resultptr = new wxRect((wxRect &)(result));
25555 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25556 }
25557 return resultobj;
25558 fail:
25559 return NULL;
25560 }
25561
25562
25563 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25564 PyObject *resultobj;
25565 wxWindow *arg1 = (wxWindow *) 0 ;
25566 wxSize result;
25567 PyObject * obj0 = 0 ;
25568 char *kwnames[] = {
25569 (char *) "self", NULL
25570 };
25571
25572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
25573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25574 if (SWIG_arg_fail(1)) SWIG_fail;
25575 {
25576 PyThreadState* __tstate = wxPyBeginAllowThreads();
25577 result = ((wxWindow const *)arg1)->GetClientSize();
25578
25579 wxPyEndAllowThreads(__tstate);
25580 if (PyErr_Occurred()) SWIG_fail;
25581 }
25582 {
25583 wxSize * resultptr;
25584 resultptr = new wxSize((wxSize &)(result));
25585 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25586 }
25587 return resultobj;
25588 fail:
25589 return NULL;
25590 }
25591
25592
25593 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25594 PyObject *resultobj;
25595 wxWindow *arg1 = (wxWindow *) 0 ;
25596 int *arg2 = (int *) 0 ;
25597 int *arg3 = (int *) 0 ;
25598 int temp2 ;
25599 int res2 = 0 ;
25600 int temp3 ;
25601 int res3 = 0 ;
25602 PyObject * obj0 = 0 ;
25603 char *kwnames[] = {
25604 (char *) "self", NULL
25605 };
25606
25607 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25608 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
25610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25611 if (SWIG_arg_fail(1)) SWIG_fail;
25612 {
25613 PyThreadState* __tstate = wxPyBeginAllowThreads();
25614 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
25615
25616 wxPyEndAllowThreads(__tstate);
25617 if (PyErr_Occurred()) SWIG_fail;
25618 }
25619 Py_INCREF(Py_None); resultobj = Py_None;
25620 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25621 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25622 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25623 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25624 return resultobj;
25625 fail:
25626 return NULL;
25627 }
25628
25629
25630 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
25631 PyObject *resultobj;
25632 wxWindow *arg1 = (wxWindow *) 0 ;
25633 wxPoint result;
25634 PyObject * obj0 = 0 ;
25635 char *kwnames[] = {
25636 (char *) "self", NULL
25637 };
25638
25639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
25640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25641 if (SWIG_arg_fail(1)) SWIG_fail;
25642 {
25643 PyThreadState* __tstate = wxPyBeginAllowThreads();
25644 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
25645
25646 wxPyEndAllowThreads(__tstate);
25647 if (PyErr_Occurred()) SWIG_fail;
25648 }
25649 {
25650 wxPoint * resultptr;
25651 resultptr = new wxPoint((wxPoint &)(result));
25652 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25653 }
25654 return resultobj;
25655 fail:
25656 return NULL;
25657 }
25658
25659
25660 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25661 PyObject *resultobj;
25662 wxWindow *arg1 = (wxWindow *) 0 ;
25663 wxRect result;
25664 PyObject * obj0 = 0 ;
25665 char *kwnames[] = {
25666 (char *) "self", NULL
25667 };
25668
25669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
25670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25671 if (SWIG_arg_fail(1)) SWIG_fail;
25672 {
25673 PyThreadState* __tstate = wxPyBeginAllowThreads();
25674 result = ((wxWindow const *)arg1)->GetClientRect();
25675
25676 wxPyEndAllowThreads(__tstate);
25677 if (PyErr_Occurred()) SWIG_fail;
25678 }
25679 {
25680 wxRect * resultptr;
25681 resultptr = new wxRect((wxRect &)(result));
25682 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25683 }
25684 return resultobj;
25685 fail:
25686 return NULL;
25687 }
25688
25689
25690 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25691 PyObject *resultobj;
25692 wxWindow *arg1 = (wxWindow *) 0 ;
25693 wxSize result;
25694 PyObject * obj0 = 0 ;
25695 char *kwnames[] = {
25696 (char *) "self", NULL
25697 };
25698
25699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
25700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25701 if (SWIG_arg_fail(1)) SWIG_fail;
25702 {
25703 PyThreadState* __tstate = wxPyBeginAllowThreads();
25704 result = ((wxWindow const *)arg1)->GetBestSize();
25705
25706 wxPyEndAllowThreads(__tstate);
25707 if (PyErr_Occurred()) SWIG_fail;
25708 }
25709 {
25710 wxSize * resultptr;
25711 resultptr = new wxSize((wxSize &)(result));
25712 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25713 }
25714 return resultobj;
25715 fail:
25716 return NULL;
25717 }
25718
25719
25720 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25721 PyObject *resultobj;
25722 wxWindow *arg1 = (wxWindow *) 0 ;
25723 int *arg2 = (int *) 0 ;
25724 int *arg3 = (int *) 0 ;
25725 int temp2 ;
25726 int res2 = 0 ;
25727 int temp3 ;
25728 int res3 = 0 ;
25729 PyObject * obj0 = 0 ;
25730 char *kwnames[] = {
25731 (char *) "self", NULL
25732 };
25733
25734 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25735 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
25737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25738 if (SWIG_arg_fail(1)) SWIG_fail;
25739 {
25740 PyThreadState* __tstate = wxPyBeginAllowThreads();
25741 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
25742
25743 wxPyEndAllowThreads(__tstate);
25744 if (PyErr_Occurred()) SWIG_fail;
25745 }
25746 Py_INCREF(Py_None); resultobj = Py_None;
25747 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25748 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25749 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25750 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25751 return resultobj;
25752 fail:
25753 return NULL;
25754 }
25755
25756
25757 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25758 PyObject *resultobj;
25759 wxWindow *arg1 = (wxWindow *) 0 ;
25760 PyObject * obj0 = 0 ;
25761 char *kwnames[] = {
25762 (char *) "self", NULL
25763 };
25764
25765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
25766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25767 if (SWIG_arg_fail(1)) SWIG_fail;
25768 {
25769 PyThreadState* __tstate = wxPyBeginAllowThreads();
25770 (arg1)->InvalidateBestSize();
25771
25772 wxPyEndAllowThreads(__tstate);
25773 if (PyErr_Occurred()) SWIG_fail;
25774 }
25775 Py_INCREF(Py_None); resultobj = Py_None;
25776 return resultobj;
25777 fail:
25778 return NULL;
25779 }
25780
25781
25782 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25783 PyObject *resultobj;
25784 wxWindow *arg1 = (wxWindow *) 0 ;
25785 wxSize result;
25786 PyObject * obj0 = 0 ;
25787 char *kwnames[] = {
25788 (char *) "self", NULL
25789 };
25790
25791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
25792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25793 if (SWIG_arg_fail(1)) SWIG_fail;
25794 {
25795 PyThreadState* __tstate = wxPyBeginAllowThreads();
25796 result = ((wxWindow const *)arg1)->GetBestFittingSize();
25797
25798 wxPyEndAllowThreads(__tstate);
25799 if (PyErr_Occurred()) SWIG_fail;
25800 }
25801 {
25802 wxSize * resultptr;
25803 resultptr = new wxSize((wxSize &)(result));
25804 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25805 }
25806 return resultobj;
25807 fail:
25808 return NULL;
25809 }
25810
25811
25812 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25813 PyObject *resultobj;
25814 wxWindow *arg1 = (wxWindow *) 0 ;
25815 wxSize result;
25816 PyObject * obj0 = 0 ;
25817 char *kwnames[] = {
25818 (char *) "self", NULL
25819 };
25820
25821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
25822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25823 if (SWIG_arg_fail(1)) SWIG_fail;
25824 {
25825 PyThreadState* __tstate = wxPyBeginAllowThreads();
25826 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
25827
25828 wxPyEndAllowThreads(__tstate);
25829 if (PyErr_Occurred()) SWIG_fail;
25830 }
25831 {
25832 wxSize * resultptr;
25833 resultptr = new wxSize((wxSize &)(result));
25834 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25835 }
25836 return resultobj;
25837 fail:
25838 return NULL;
25839 }
25840
25841
25842 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
25843 PyObject *resultobj;
25844 wxWindow *arg1 = (wxWindow *) 0 ;
25845 int arg2 = (int) wxBOTH ;
25846 PyObject * obj0 = 0 ;
25847 PyObject * obj1 = 0 ;
25848 char *kwnames[] = {
25849 (char *) "self",(char *) "direction", NULL
25850 };
25851
25852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
25853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25854 if (SWIG_arg_fail(1)) SWIG_fail;
25855 if (obj1) {
25856 {
25857 arg2 = (int)(SWIG_As_int(obj1));
25858 if (SWIG_arg_fail(2)) SWIG_fail;
25859 }
25860 }
25861 {
25862 PyThreadState* __tstate = wxPyBeginAllowThreads();
25863 (arg1)->Center(arg2);
25864
25865 wxPyEndAllowThreads(__tstate);
25866 if (PyErr_Occurred()) SWIG_fail;
25867 }
25868 Py_INCREF(Py_None); resultobj = Py_None;
25869 return resultobj;
25870 fail:
25871 return NULL;
25872 }
25873
25874
25875 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
25876 PyObject *resultobj;
25877 wxWindow *arg1 = (wxWindow *) 0 ;
25878 int arg2 = (int) wxBOTH ;
25879 PyObject * obj0 = 0 ;
25880 PyObject * obj1 = 0 ;
25881 char *kwnames[] = {
25882 (char *) "self",(char *) "dir", NULL
25883 };
25884
25885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
25886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25887 if (SWIG_arg_fail(1)) SWIG_fail;
25888 if (obj1) {
25889 {
25890 arg2 = (int)(SWIG_As_int(obj1));
25891 if (SWIG_arg_fail(2)) SWIG_fail;
25892 }
25893 }
25894 {
25895 PyThreadState* __tstate = wxPyBeginAllowThreads();
25896 (arg1)->CenterOnScreen(arg2);
25897
25898 wxPyEndAllowThreads(__tstate);
25899 if (PyErr_Occurred()) SWIG_fail;
25900 }
25901 Py_INCREF(Py_None); resultobj = Py_None;
25902 return resultobj;
25903 fail:
25904 return NULL;
25905 }
25906
25907
25908 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
25909 PyObject *resultobj;
25910 wxWindow *arg1 = (wxWindow *) 0 ;
25911 int arg2 = (int) wxBOTH ;
25912 PyObject * obj0 = 0 ;
25913 PyObject * obj1 = 0 ;
25914 char *kwnames[] = {
25915 (char *) "self",(char *) "dir", NULL
25916 };
25917
25918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
25919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25920 if (SWIG_arg_fail(1)) SWIG_fail;
25921 if (obj1) {
25922 {
25923 arg2 = (int)(SWIG_As_int(obj1));
25924 if (SWIG_arg_fail(2)) SWIG_fail;
25925 }
25926 }
25927 {
25928 PyThreadState* __tstate = wxPyBeginAllowThreads();
25929 (arg1)->CenterOnParent(arg2);
25930
25931 wxPyEndAllowThreads(__tstate);
25932 if (PyErr_Occurred()) SWIG_fail;
25933 }
25934 Py_INCREF(Py_None); resultobj = Py_None;
25935 return resultobj;
25936 fail:
25937 return NULL;
25938 }
25939
25940
25941 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
25942 PyObject *resultobj;
25943 wxWindow *arg1 = (wxWindow *) 0 ;
25944 PyObject * obj0 = 0 ;
25945 char *kwnames[] = {
25946 (char *) "self", NULL
25947 };
25948
25949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
25950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25951 if (SWIG_arg_fail(1)) SWIG_fail;
25952 {
25953 PyThreadState* __tstate = wxPyBeginAllowThreads();
25954 (arg1)->Fit();
25955
25956 wxPyEndAllowThreads(__tstate);
25957 if (PyErr_Occurred()) SWIG_fail;
25958 }
25959 Py_INCREF(Py_None); resultobj = Py_None;
25960 return resultobj;
25961 fail:
25962 return NULL;
25963 }
25964
25965
25966 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
25967 PyObject *resultobj;
25968 wxWindow *arg1 = (wxWindow *) 0 ;
25969 PyObject * obj0 = 0 ;
25970 char *kwnames[] = {
25971 (char *) "self", NULL
25972 };
25973
25974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
25975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25976 if (SWIG_arg_fail(1)) SWIG_fail;
25977 {
25978 PyThreadState* __tstate = wxPyBeginAllowThreads();
25979 (arg1)->FitInside();
25980
25981 wxPyEndAllowThreads(__tstate);
25982 if (PyErr_Occurred()) SWIG_fail;
25983 }
25984 Py_INCREF(Py_None); resultobj = Py_None;
25985 return resultobj;
25986 fail:
25987 return NULL;
25988 }
25989
25990
25991 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
25992 PyObject *resultobj;
25993 wxWindow *arg1 = (wxWindow *) 0 ;
25994 int arg2 ;
25995 int arg3 ;
25996 int arg4 = (int) -1 ;
25997 int arg5 = (int) -1 ;
25998 int arg6 = (int) -1 ;
25999 int arg7 = (int) -1 ;
26000 PyObject * obj0 = 0 ;
26001 PyObject * obj1 = 0 ;
26002 PyObject * obj2 = 0 ;
26003 PyObject * obj3 = 0 ;
26004 PyObject * obj4 = 0 ;
26005 PyObject * obj5 = 0 ;
26006 PyObject * obj6 = 0 ;
26007 char *kwnames[] = {
26008 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26009 };
26010
26011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26013 if (SWIG_arg_fail(1)) SWIG_fail;
26014 {
26015 arg2 = (int)(SWIG_As_int(obj1));
26016 if (SWIG_arg_fail(2)) SWIG_fail;
26017 }
26018 {
26019 arg3 = (int)(SWIG_As_int(obj2));
26020 if (SWIG_arg_fail(3)) SWIG_fail;
26021 }
26022 if (obj3) {
26023 {
26024 arg4 = (int)(SWIG_As_int(obj3));
26025 if (SWIG_arg_fail(4)) SWIG_fail;
26026 }
26027 }
26028 if (obj4) {
26029 {
26030 arg5 = (int)(SWIG_As_int(obj4));
26031 if (SWIG_arg_fail(5)) SWIG_fail;
26032 }
26033 }
26034 if (obj5) {
26035 {
26036 arg6 = (int)(SWIG_As_int(obj5));
26037 if (SWIG_arg_fail(6)) SWIG_fail;
26038 }
26039 }
26040 if (obj6) {
26041 {
26042 arg7 = (int)(SWIG_As_int(obj6));
26043 if (SWIG_arg_fail(7)) SWIG_fail;
26044 }
26045 }
26046 {
26047 PyThreadState* __tstate = wxPyBeginAllowThreads();
26048 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26049
26050 wxPyEndAllowThreads(__tstate);
26051 if (PyErr_Occurred()) SWIG_fail;
26052 }
26053 Py_INCREF(Py_None); resultobj = Py_None;
26054 return resultobj;
26055 fail:
26056 return NULL;
26057 }
26058
26059
26060 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26061 PyObject *resultobj;
26062 wxWindow *arg1 = (wxWindow *) 0 ;
26063 wxSize *arg2 = 0 ;
26064 wxSize const &arg3_defvalue = wxDefaultSize ;
26065 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26066 wxSize const &arg4_defvalue = wxDefaultSize ;
26067 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26068 wxSize temp2 ;
26069 wxSize temp3 ;
26070 wxSize temp4 ;
26071 PyObject * obj0 = 0 ;
26072 PyObject * obj1 = 0 ;
26073 PyObject * obj2 = 0 ;
26074 PyObject * obj3 = 0 ;
26075 char *kwnames[] = {
26076 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26077 };
26078
26079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26081 if (SWIG_arg_fail(1)) SWIG_fail;
26082 {
26083 arg2 = &temp2;
26084 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26085 }
26086 if (obj2) {
26087 {
26088 arg3 = &temp3;
26089 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26090 }
26091 }
26092 if (obj3) {
26093 {
26094 arg4 = &temp4;
26095 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26096 }
26097 }
26098 {
26099 PyThreadState* __tstate = wxPyBeginAllowThreads();
26100 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26101
26102 wxPyEndAllowThreads(__tstate);
26103 if (PyErr_Occurred()) SWIG_fail;
26104 }
26105 Py_INCREF(Py_None); resultobj = Py_None;
26106 return resultobj;
26107 fail:
26108 return NULL;
26109 }
26110
26111
26112 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26113 PyObject *resultobj;
26114 wxWindow *arg1 = (wxWindow *) 0 ;
26115 int arg2 ;
26116 int arg3 ;
26117 int arg4 = (int) -1 ;
26118 int arg5 = (int) -1 ;
26119 PyObject * obj0 = 0 ;
26120 PyObject * obj1 = 0 ;
26121 PyObject * obj2 = 0 ;
26122 PyObject * obj3 = 0 ;
26123 PyObject * obj4 = 0 ;
26124 char *kwnames[] = {
26125 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26126 };
26127
26128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26130 if (SWIG_arg_fail(1)) SWIG_fail;
26131 {
26132 arg2 = (int)(SWIG_As_int(obj1));
26133 if (SWIG_arg_fail(2)) SWIG_fail;
26134 }
26135 {
26136 arg3 = (int)(SWIG_As_int(obj2));
26137 if (SWIG_arg_fail(3)) SWIG_fail;
26138 }
26139 if (obj3) {
26140 {
26141 arg4 = (int)(SWIG_As_int(obj3));
26142 if (SWIG_arg_fail(4)) SWIG_fail;
26143 }
26144 }
26145 if (obj4) {
26146 {
26147 arg5 = (int)(SWIG_As_int(obj4));
26148 if (SWIG_arg_fail(5)) SWIG_fail;
26149 }
26150 }
26151 {
26152 PyThreadState* __tstate = wxPyBeginAllowThreads();
26153 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26154
26155 wxPyEndAllowThreads(__tstate);
26156 if (PyErr_Occurred()) SWIG_fail;
26157 }
26158 Py_INCREF(Py_None); resultobj = Py_None;
26159 return resultobj;
26160 fail:
26161 return NULL;
26162 }
26163
26164
26165 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26166 PyObject *resultobj;
26167 wxWindow *arg1 = (wxWindow *) 0 ;
26168 wxSize *arg2 = 0 ;
26169 wxSize const &arg3_defvalue = wxDefaultSize ;
26170 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26171 wxSize temp2 ;
26172 wxSize temp3 ;
26173 PyObject * obj0 = 0 ;
26174 PyObject * obj1 = 0 ;
26175 PyObject * obj2 = 0 ;
26176 char *kwnames[] = {
26177 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26178 };
26179
26180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26182 if (SWIG_arg_fail(1)) SWIG_fail;
26183 {
26184 arg2 = &temp2;
26185 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26186 }
26187 if (obj2) {
26188 {
26189 arg3 = &temp3;
26190 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26191 }
26192 }
26193 {
26194 PyThreadState* __tstate = wxPyBeginAllowThreads();
26195 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26196
26197 wxPyEndAllowThreads(__tstate);
26198 if (PyErr_Occurred()) SWIG_fail;
26199 }
26200 Py_INCREF(Py_None); resultobj = Py_None;
26201 return resultobj;
26202 fail:
26203 return NULL;
26204 }
26205
26206
26207 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26208 PyObject *resultobj;
26209 wxWindow *arg1 = (wxWindow *) 0 ;
26210 wxSize result;
26211 PyObject * obj0 = 0 ;
26212 char *kwnames[] = {
26213 (char *) "self", NULL
26214 };
26215
26216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26218 if (SWIG_arg_fail(1)) SWIG_fail;
26219 {
26220 PyThreadState* __tstate = wxPyBeginAllowThreads();
26221 result = ((wxWindow const *)arg1)->GetMaxSize();
26222
26223 wxPyEndAllowThreads(__tstate);
26224 if (PyErr_Occurred()) SWIG_fail;
26225 }
26226 {
26227 wxSize * resultptr;
26228 resultptr = new wxSize((wxSize &)(result));
26229 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26230 }
26231 return resultobj;
26232 fail:
26233 return NULL;
26234 }
26235
26236
26237 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26238 PyObject *resultobj;
26239 wxWindow *arg1 = (wxWindow *) 0 ;
26240 wxSize result;
26241 PyObject * obj0 = 0 ;
26242 char *kwnames[] = {
26243 (char *) "self", NULL
26244 };
26245
26246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26248 if (SWIG_arg_fail(1)) SWIG_fail;
26249 {
26250 PyThreadState* __tstate = wxPyBeginAllowThreads();
26251 result = ((wxWindow const *)arg1)->GetMinSize();
26252
26253 wxPyEndAllowThreads(__tstate);
26254 if (PyErr_Occurred()) SWIG_fail;
26255 }
26256 {
26257 wxSize * resultptr;
26258 resultptr = new wxSize((wxSize &)(result));
26259 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26260 }
26261 return resultobj;
26262 fail:
26263 return NULL;
26264 }
26265
26266
26267 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26268 PyObject *resultobj;
26269 wxWindow *arg1 = (wxWindow *) 0 ;
26270 wxSize *arg2 = 0 ;
26271 wxSize temp2 ;
26272 PyObject * obj0 = 0 ;
26273 PyObject * obj1 = 0 ;
26274 char *kwnames[] = {
26275 (char *) "self",(char *) "minSize", NULL
26276 };
26277
26278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26280 if (SWIG_arg_fail(1)) SWIG_fail;
26281 {
26282 arg2 = &temp2;
26283 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26284 }
26285 {
26286 PyThreadState* __tstate = wxPyBeginAllowThreads();
26287 (arg1)->SetMinSize((wxSize const &)*arg2);
26288
26289 wxPyEndAllowThreads(__tstate);
26290 if (PyErr_Occurred()) SWIG_fail;
26291 }
26292 Py_INCREF(Py_None); resultobj = Py_None;
26293 return resultobj;
26294 fail:
26295 return NULL;
26296 }
26297
26298
26299 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26300 PyObject *resultobj;
26301 wxWindow *arg1 = (wxWindow *) 0 ;
26302 wxSize *arg2 = 0 ;
26303 wxSize temp2 ;
26304 PyObject * obj0 = 0 ;
26305 PyObject * obj1 = 0 ;
26306 char *kwnames[] = {
26307 (char *) "self",(char *) "maxSize", NULL
26308 };
26309
26310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26312 if (SWIG_arg_fail(1)) SWIG_fail;
26313 {
26314 arg2 = &temp2;
26315 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26316 }
26317 {
26318 PyThreadState* __tstate = wxPyBeginAllowThreads();
26319 (arg1)->SetMaxSize((wxSize const &)*arg2);
26320
26321 wxPyEndAllowThreads(__tstate);
26322 if (PyErr_Occurred()) SWIG_fail;
26323 }
26324 Py_INCREF(Py_None); resultobj = Py_None;
26325 return resultobj;
26326 fail:
26327 return NULL;
26328 }
26329
26330
26331 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26332 PyObject *resultobj;
26333 wxWindow *arg1 = (wxWindow *) 0 ;
26334 int result;
26335 PyObject * obj0 = 0 ;
26336 char *kwnames[] = {
26337 (char *) "self", NULL
26338 };
26339
26340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
26341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26342 if (SWIG_arg_fail(1)) SWIG_fail;
26343 {
26344 PyThreadState* __tstate = wxPyBeginAllowThreads();
26345 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26346
26347 wxPyEndAllowThreads(__tstate);
26348 if (PyErr_Occurred()) SWIG_fail;
26349 }
26350 {
26351 resultobj = SWIG_From_int((int)(result));
26352 }
26353 return resultobj;
26354 fail:
26355 return NULL;
26356 }
26357
26358
26359 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26360 PyObject *resultobj;
26361 wxWindow *arg1 = (wxWindow *) 0 ;
26362 int result;
26363 PyObject * obj0 = 0 ;
26364 char *kwnames[] = {
26365 (char *) "self", NULL
26366 };
26367
26368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26370 if (SWIG_arg_fail(1)) SWIG_fail;
26371 {
26372 PyThreadState* __tstate = wxPyBeginAllowThreads();
26373 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26374
26375 wxPyEndAllowThreads(__tstate);
26376 if (PyErr_Occurred()) SWIG_fail;
26377 }
26378 {
26379 resultobj = SWIG_From_int((int)(result));
26380 }
26381 return resultobj;
26382 fail:
26383 return NULL;
26384 }
26385
26386
26387 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26388 PyObject *resultobj;
26389 wxWindow *arg1 = (wxWindow *) 0 ;
26390 int result;
26391 PyObject * obj0 = 0 ;
26392 char *kwnames[] = {
26393 (char *) "self", NULL
26394 };
26395
26396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26398 if (SWIG_arg_fail(1)) SWIG_fail;
26399 {
26400 PyThreadState* __tstate = wxPyBeginAllowThreads();
26401 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26402
26403 wxPyEndAllowThreads(__tstate);
26404 if (PyErr_Occurred()) SWIG_fail;
26405 }
26406 {
26407 resultobj = SWIG_From_int((int)(result));
26408 }
26409 return resultobj;
26410 fail:
26411 return NULL;
26412 }
26413
26414
26415 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26416 PyObject *resultobj;
26417 wxWindow *arg1 = (wxWindow *) 0 ;
26418 int result;
26419 PyObject * obj0 = 0 ;
26420 char *kwnames[] = {
26421 (char *) "self", NULL
26422 };
26423
26424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26426 if (SWIG_arg_fail(1)) SWIG_fail;
26427 {
26428 PyThreadState* __tstate = wxPyBeginAllowThreads();
26429 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26430
26431 wxPyEndAllowThreads(__tstate);
26432 if (PyErr_Occurred()) SWIG_fail;
26433 }
26434 {
26435 resultobj = SWIG_From_int((int)(result));
26436 }
26437 return resultobj;
26438 fail:
26439 return NULL;
26440 }
26441
26442
26443 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26444 PyObject *resultobj;
26445 wxWindow *arg1 = (wxWindow *) 0 ;
26446 wxSize *arg2 = 0 ;
26447 wxSize temp2 ;
26448 PyObject * obj0 = 0 ;
26449 PyObject * obj1 = 0 ;
26450 char *kwnames[] = {
26451 (char *) "self",(char *) "size", NULL
26452 };
26453
26454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26456 if (SWIG_arg_fail(1)) SWIG_fail;
26457 {
26458 arg2 = &temp2;
26459 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26460 }
26461 {
26462 PyThreadState* __tstate = wxPyBeginAllowThreads();
26463 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26464
26465 wxPyEndAllowThreads(__tstate);
26466 if (PyErr_Occurred()) SWIG_fail;
26467 }
26468 Py_INCREF(Py_None); resultobj = Py_None;
26469 return resultobj;
26470 fail:
26471 return NULL;
26472 }
26473
26474
26475 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26476 PyObject *resultobj;
26477 wxWindow *arg1 = (wxWindow *) 0 ;
26478 int arg2 ;
26479 int arg3 ;
26480 PyObject * obj0 = 0 ;
26481 PyObject * obj1 = 0 ;
26482 PyObject * obj2 = 0 ;
26483 char *kwnames[] = {
26484 (char *) "self",(char *) "w",(char *) "h", NULL
26485 };
26486
26487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26489 if (SWIG_arg_fail(1)) SWIG_fail;
26490 {
26491 arg2 = (int)(SWIG_As_int(obj1));
26492 if (SWIG_arg_fail(2)) SWIG_fail;
26493 }
26494 {
26495 arg3 = (int)(SWIG_As_int(obj2));
26496 if (SWIG_arg_fail(3)) SWIG_fail;
26497 }
26498 {
26499 PyThreadState* __tstate = wxPyBeginAllowThreads();
26500 (arg1)->SetVirtualSize(arg2,arg3);
26501
26502 wxPyEndAllowThreads(__tstate);
26503 if (PyErr_Occurred()) SWIG_fail;
26504 }
26505 Py_INCREF(Py_None); resultobj = Py_None;
26506 return resultobj;
26507 fail:
26508 return NULL;
26509 }
26510
26511
26512 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26513 PyObject *resultobj;
26514 wxWindow *arg1 = (wxWindow *) 0 ;
26515 wxSize result;
26516 PyObject * obj0 = 0 ;
26517 char *kwnames[] = {
26518 (char *) "self", NULL
26519 };
26520
26521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
26522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26523 if (SWIG_arg_fail(1)) SWIG_fail;
26524 {
26525 PyThreadState* __tstate = wxPyBeginAllowThreads();
26526 result = ((wxWindow const *)arg1)->GetVirtualSize();
26527
26528 wxPyEndAllowThreads(__tstate);
26529 if (PyErr_Occurred()) SWIG_fail;
26530 }
26531 {
26532 wxSize * resultptr;
26533 resultptr = new wxSize((wxSize &)(result));
26534 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26535 }
26536 return resultobj;
26537 fail:
26538 return NULL;
26539 }
26540
26541
26542 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26543 PyObject *resultobj;
26544 wxWindow *arg1 = (wxWindow *) 0 ;
26545 int *arg2 = (int *) 0 ;
26546 int *arg3 = (int *) 0 ;
26547 int temp2 ;
26548 int res2 = 0 ;
26549 int temp3 ;
26550 int res3 = 0 ;
26551 PyObject * obj0 = 0 ;
26552 char *kwnames[] = {
26553 (char *) "self", NULL
26554 };
26555
26556 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26557 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
26559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26560 if (SWIG_arg_fail(1)) SWIG_fail;
26561 {
26562 PyThreadState* __tstate = wxPyBeginAllowThreads();
26563 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
26564
26565 wxPyEndAllowThreads(__tstate);
26566 if (PyErr_Occurred()) SWIG_fail;
26567 }
26568 Py_INCREF(Py_None); resultobj = Py_None;
26569 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26570 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26571 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26572 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26573 return resultobj;
26574 fail:
26575 return NULL;
26576 }
26577
26578
26579 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26580 PyObject *resultobj;
26581 wxWindow *arg1 = (wxWindow *) 0 ;
26582 wxSize result;
26583 PyObject * obj0 = 0 ;
26584 char *kwnames[] = {
26585 (char *) "self", NULL
26586 };
26587
26588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
26589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26590 if (SWIG_arg_fail(1)) SWIG_fail;
26591 {
26592 PyThreadState* __tstate = wxPyBeginAllowThreads();
26593 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
26594
26595 wxPyEndAllowThreads(__tstate);
26596 if (PyErr_Occurred()) SWIG_fail;
26597 }
26598 {
26599 wxSize * resultptr;
26600 resultptr = new wxSize((wxSize &)(result));
26601 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26602 }
26603 return resultobj;
26604 fail:
26605 return NULL;
26606 }
26607
26608
26609 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
26610 PyObject *resultobj;
26611 wxWindow *arg1 = (wxWindow *) 0 ;
26612 bool arg2 = (bool) true ;
26613 bool result;
26614 PyObject * obj0 = 0 ;
26615 PyObject * obj1 = 0 ;
26616 char *kwnames[] = {
26617 (char *) "self",(char *) "show", NULL
26618 };
26619
26620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
26621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26622 if (SWIG_arg_fail(1)) SWIG_fail;
26623 if (obj1) {
26624 {
26625 arg2 = (bool)(SWIG_As_bool(obj1));
26626 if (SWIG_arg_fail(2)) SWIG_fail;
26627 }
26628 }
26629 {
26630 PyThreadState* __tstate = wxPyBeginAllowThreads();
26631 result = (bool)(arg1)->Show(arg2);
26632
26633 wxPyEndAllowThreads(__tstate);
26634 if (PyErr_Occurred()) SWIG_fail;
26635 }
26636 {
26637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26638 }
26639 return resultobj;
26640 fail:
26641 return NULL;
26642 }
26643
26644
26645 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
26646 PyObject *resultobj;
26647 wxWindow *arg1 = (wxWindow *) 0 ;
26648 bool result;
26649 PyObject * obj0 = 0 ;
26650 char *kwnames[] = {
26651 (char *) "self", NULL
26652 };
26653
26654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
26655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26656 if (SWIG_arg_fail(1)) SWIG_fail;
26657 {
26658 PyThreadState* __tstate = wxPyBeginAllowThreads();
26659 result = (bool)(arg1)->Hide();
26660
26661 wxPyEndAllowThreads(__tstate);
26662 if (PyErr_Occurred()) SWIG_fail;
26663 }
26664 {
26665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26666 }
26667 return resultobj;
26668 fail:
26669 return NULL;
26670 }
26671
26672
26673 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
26674 PyObject *resultobj;
26675 wxWindow *arg1 = (wxWindow *) 0 ;
26676 bool arg2 = (bool) true ;
26677 bool result;
26678 PyObject * obj0 = 0 ;
26679 PyObject * obj1 = 0 ;
26680 char *kwnames[] = {
26681 (char *) "self",(char *) "enable", NULL
26682 };
26683
26684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
26685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26686 if (SWIG_arg_fail(1)) SWIG_fail;
26687 if (obj1) {
26688 {
26689 arg2 = (bool)(SWIG_As_bool(obj1));
26690 if (SWIG_arg_fail(2)) SWIG_fail;
26691 }
26692 }
26693 {
26694 PyThreadState* __tstate = wxPyBeginAllowThreads();
26695 result = (bool)(arg1)->Enable(arg2);
26696
26697 wxPyEndAllowThreads(__tstate);
26698 if (PyErr_Occurred()) SWIG_fail;
26699 }
26700 {
26701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26702 }
26703 return resultobj;
26704 fail:
26705 return NULL;
26706 }
26707
26708
26709 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
26710 PyObject *resultobj;
26711 wxWindow *arg1 = (wxWindow *) 0 ;
26712 bool result;
26713 PyObject * obj0 = 0 ;
26714 char *kwnames[] = {
26715 (char *) "self", NULL
26716 };
26717
26718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
26719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26720 if (SWIG_arg_fail(1)) SWIG_fail;
26721 {
26722 PyThreadState* __tstate = wxPyBeginAllowThreads();
26723 result = (bool)(arg1)->Disable();
26724
26725 wxPyEndAllowThreads(__tstate);
26726 if (PyErr_Occurred()) SWIG_fail;
26727 }
26728 {
26729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26730 }
26731 return resultobj;
26732 fail:
26733 return NULL;
26734 }
26735
26736
26737 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
26738 PyObject *resultobj;
26739 wxWindow *arg1 = (wxWindow *) 0 ;
26740 bool result;
26741 PyObject * obj0 = 0 ;
26742 char *kwnames[] = {
26743 (char *) "self", NULL
26744 };
26745
26746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
26747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26748 if (SWIG_arg_fail(1)) SWIG_fail;
26749 {
26750 PyThreadState* __tstate = wxPyBeginAllowThreads();
26751 result = (bool)((wxWindow const *)arg1)->IsShown();
26752
26753 wxPyEndAllowThreads(__tstate);
26754 if (PyErr_Occurred()) SWIG_fail;
26755 }
26756 {
26757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26758 }
26759 return resultobj;
26760 fail:
26761 return NULL;
26762 }
26763
26764
26765 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
26766 PyObject *resultobj;
26767 wxWindow *arg1 = (wxWindow *) 0 ;
26768 bool result;
26769 PyObject * obj0 = 0 ;
26770 char *kwnames[] = {
26771 (char *) "self", NULL
26772 };
26773
26774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
26775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26776 if (SWIG_arg_fail(1)) SWIG_fail;
26777 {
26778 PyThreadState* __tstate = wxPyBeginAllowThreads();
26779 result = (bool)((wxWindow const *)arg1)->IsEnabled();
26780
26781 wxPyEndAllowThreads(__tstate);
26782 if (PyErr_Occurred()) SWIG_fail;
26783 }
26784 {
26785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26786 }
26787 return resultobj;
26788 fail:
26789 return NULL;
26790 }
26791
26792
26793 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26794 PyObject *resultobj;
26795 wxWindow *arg1 = (wxWindow *) 0 ;
26796 long arg2 ;
26797 PyObject * obj0 = 0 ;
26798 PyObject * obj1 = 0 ;
26799 char *kwnames[] = {
26800 (char *) "self",(char *) "style", NULL
26801 };
26802
26803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
26804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26805 if (SWIG_arg_fail(1)) SWIG_fail;
26806 {
26807 arg2 = (long)(SWIG_As_long(obj1));
26808 if (SWIG_arg_fail(2)) SWIG_fail;
26809 }
26810 {
26811 PyThreadState* __tstate = wxPyBeginAllowThreads();
26812 (arg1)->SetWindowStyleFlag(arg2);
26813
26814 wxPyEndAllowThreads(__tstate);
26815 if (PyErr_Occurred()) SWIG_fail;
26816 }
26817 Py_INCREF(Py_None); resultobj = Py_None;
26818 return resultobj;
26819 fail:
26820 return NULL;
26821 }
26822
26823
26824 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26825 PyObject *resultobj;
26826 wxWindow *arg1 = (wxWindow *) 0 ;
26827 long result;
26828 PyObject * obj0 = 0 ;
26829 char *kwnames[] = {
26830 (char *) "self", NULL
26831 };
26832
26833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
26834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26835 if (SWIG_arg_fail(1)) SWIG_fail;
26836 {
26837 PyThreadState* __tstate = wxPyBeginAllowThreads();
26838 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
26839
26840 wxPyEndAllowThreads(__tstate);
26841 if (PyErr_Occurred()) SWIG_fail;
26842 }
26843 {
26844 resultobj = SWIG_From_long((long)(result));
26845 }
26846 return resultobj;
26847 fail:
26848 return NULL;
26849 }
26850
26851
26852 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26853 PyObject *resultobj;
26854 wxWindow *arg1 = (wxWindow *) 0 ;
26855 int arg2 ;
26856 bool result;
26857 PyObject * obj0 = 0 ;
26858 PyObject * obj1 = 0 ;
26859 char *kwnames[] = {
26860 (char *) "self",(char *) "flag", NULL
26861 };
26862
26863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
26864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26865 if (SWIG_arg_fail(1)) SWIG_fail;
26866 {
26867 arg2 = (int)(SWIG_As_int(obj1));
26868 if (SWIG_arg_fail(2)) SWIG_fail;
26869 }
26870 {
26871 PyThreadState* __tstate = wxPyBeginAllowThreads();
26872 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
26873
26874 wxPyEndAllowThreads(__tstate);
26875 if (PyErr_Occurred()) SWIG_fail;
26876 }
26877 {
26878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26879 }
26880 return resultobj;
26881 fail:
26882 return NULL;
26883 }
26884
26885
26886 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
26887 PyObject *resultobj;
26888 wxWindow *arg1 = (wxWindow *) 0 ;
26889 bool result;
26890 PyObject * obj0 = 0 ;
26891 char *kwnames[] = {
26892 (char *) "self", NULL
26893 };
26894
26895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
26896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26897 if (SWIG_arg_fail(1)) SWIG_fail;
26898 {
26899 PyThreadState* __tstate = wxPyBeginAllowThreads();
26900 result = (bool)((wxWindow const *)arg1)->IsRetained();
26901
26902 wxPyEndAllowThreads(__tstate);
26903 if (PyErr_Occurred()) SWIG_fail;
26904 }
26905 {
26906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26907 }
26908 return resultobj;
26909 fail:
26910 return NULL;
26911 }
26912
26913
26914 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
26915 PyObject *resultobj;
26916 wxWindow *arg1 = (wxWindow *) 0 ;
26917 long arg2 ;
26918 PyObject * obj0 = 0 ;
26919 PyObject * obj1 = 0 ;
26920 char *kwnames[] = {
26921 (char *) "self",(char *) "exStyle", NULL
26922 };
26923
26924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
26925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26926 if (SWIG_arg_fail(1)) SWIG_fail;
26927 {
26928 arg2 = (long)(SWIG_As_long(obj1));
26929 if (SWIG_arg_fail(2)) SWIG_fail;
26930 }
26931 {
26932 PyThreadState* __tstate = wxPyBeginAllowThreads();
26933 (arg1)->SetExtraStyle(arg2);
26934
26935 wxPyEndAllowThreads(__tstate);
26936 if (PyErr_Occurred()) SWIG_fail;
26937 }
26938 Py_INCREF(Py_None); resultobj = Py_None;
26939 return resultobj;
26940 fail:
26941 return NULL;
26942 }
26943
26944
26945 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
26946 PyObject *resultobj;
26947 wxWindow *arg1 = (wxWindow *) 0 ;
26948 long result;
26949 PyObject * obj0 = 0 ;
26950 char *kwnames[] = {
26951 (char *) "self", NULL
26952 };
26953
26954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
26955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26956 if (SWIG_arg_fail(1)) SWIG_fail;
26957 {
26958 PyThreadState* __tstate = wxPyBeginAllowThreads();
26959 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
26960
26961 wxPyEndAllowThreads(__tstate);
26962 if (PyErr_Occurred()) SWIG_fail;
26963 }
26964 {
26965 resultobj = SWIG_From_long((long)(result));
26966 }
26967 return resultobj;
26968 fail:
26969 return NULL;
26970 }
26971
26972
26973 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
26974 PyObject *resultobj;
26975 wxWindow *arg1 = (wxWindow *) 0 ;
26976 bool arg2 = (bool) true ;
26977 PyObject * obj0 = 0 ;
26978 PyObject * obj1 = 0 ;
26979 char *kwnames[] = {
26980 (char *) "self",(char *) "modal", NULL
26981 };
26982
26983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
26984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26985 if (SWIG_arg_fail(1)) SWIG_fail;
26986 if (obj1) {
26987 {
26988 arg2 = (bool)(SWIG_As_bool(obj1));
26989 if (SWIG_arg_fail(2)) SWIG_fail;
26990 }
26991 }
26992 {
26993 PyThreadState* __tstate = wxPyBeginAllowThreads();
26994 (arg1)->MakeModal(arg2);
26995
26996 wxPyEndAllowThreads(__tstate);
26997 if (PyErr_Occurred()) SWIG_fail;
26998 }
26999 Py_INCREF(Py_None); resultobj = Py_None;
27000 return resultobj;
27001 fail:
27002 return NULL;
27003 }
27004
27005
27006 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27007 PyObject *resultobj;
27008 wxWindow *arg1 = (wxWindow *) 0 ;
27009 bool arg2 ;
27010 PyObject * obj0 = 0 ;
27011 PyObject * obj1 = 0 ;
27012 char *kwnames[] = {
27013 (char *) "self",(char *) "enableTheme", NULL
27014 };
27015
27016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27018 if (SWIG_arg_fail(1)) SWIG_fail;
27019 {
27020 arg2 = (bool)(SWIG_As_bool(obj1));
27021 if (SWIG_arg_fail(2)) SWIG_fail;
27022 }
27023 {
27024 PyThreadState* __tstate = wxPyBeginAllowThreads();
27025 (arg1)->SetThemeEnabled(arg2);
27026
27027 wxPyEndAllowThreads(__tstate);
27028 if (PyErr_Occurred()) SWIG_fail;
27029 }
27030 Py_INCREF(Py_None); resultobj = Py_None;
27031 return resultobj;
27032 fail:
27033 return NULL;
27034 }
27035
27036
27037 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27038 PyObject *resultobj;
27039 wxWindow *arg1 = (wxWindow *) 0 ;
27040 bool result;
27041 PyObject * obj0 = 0 ;
27042 char *kwnames[] = {
27043 (char *) "self", NULL
27044 };
27045
27046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27048 if (SWIG_arg_fail(1)) SWIG_fail;
27049 {
27050 PyThreadState* __tstate = wxPyBeginAllowThreads();
27051 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27052
27053 wxPyEndAllowThreads(__tstate);
27054 if (PyErr_Occurred()) SWIG_fail;
27055 }
27056 {
27057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27058 }
27059 return resultobj;
27060 fail:
27061 return NULL;
27062 }
27063
27064
27065 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27066 PyObject *resultobj;
27067 wxWindow *arg1 = (wxWindow *) 0 ;
27068 PyObject * obj0 = 0 ;
27069 char *kwnames[] = {
27070 (char *) "self", NULL
27071 };
27072
27073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27075 if (SWIG_arg_fail(1)) SWIG_fail;
27076 {
27077 PyThreadState* __tstate = wxPyBeginAllowThreads();
27078 (arg1)->SetFocus();
27079
27080 wxPyEndAllowThreads(__tstate);
27081 if (PyErr_Occurred()) SWIG_fail;
27082 }
27083 Py_INCREF(Py_None); resultobj = Py_None;
27084 return resultobj;
27085 fail:
27086 return NULL;
27087 }
27088
27089
27090 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27091 PyObject *resultobj;
27092 wxWindow *arg1 = (wxWindow *) 0 ;
27093 PyObject * obj0 = 0 ;
27094 char *kwnames[] = {
27095 (char *) "self", NULL
27096 };
27097
27098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27100 if (SWIG_arg_fail(1)) SWIG_fail;
27101 {
27102 PyThreadState* __tstate = wxPyBeginAllowThreads();
27103 (arg1)->SetFocusFromKbd();
27104
27105 wxPyEndAllowThreads(__tstate);
27106 if (PyErr_Occurred()) SWIG_fail;
27107 }
27108 Py_INCREF(Py_None); resultobj = Py_None;
27109 return resultobj;
27110 fail:
27111 return NULL;
27112 }
27113
27114
27115 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27116 PyObject *resultobj;
27117 wxWindow *result;
27118 char *kwnames[] = {
27119 NULL
27120 };
27121
27122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27123 {
27124 if (!wxPyCheckForApp()) SWIG_fail;
27125 PyThreadState* __tstate = wxPyBeginAllowThreads();
27126 result = (wxWindow *)wxWindow::FindFocus();
27127
27128 wxPyEndAllowThreads(__tstate);
27129 if (PyErr_Occurred()) SWIG_fail;
27130 }
27131 {
27132 resultobj = wxPyMake_wxObject(result, 0);
27133 }
27134 return resultobj;
27135 fail:
27136 return NULL;
27137 }
27138
27139
27140 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27141 PyObject *resultobj;
27142 wxWindow *arg1 = (wxWindow *) 0 ;
27143 bool result;
27144 PyObject * obj0 = 0 ;
27145 char *kwnames[] = {
27146 (char *) "self", NULL
27147 };
27148
27149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27151 if (SWIG_arg_fail(1)) SWIG_fail;
27152 {
27153 PyThreadState* __tstate = wxPyBeginAllowThreads();
27154 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27155
27156 wxPyEndAllowThreads(__tstate);
27157 if (PyErr_Occurred()) SWIG_fail;
27158 }
27159 {
27160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27161 }
27162 return resultobj;
27163 fail:
27164 return NULL;
27165 }
27166
27167
27168 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27169 PyObject *resultobj;
27170 wxWindow *arg1 = (wxWindow *) 0 ;
27171 bool result;
27172 PyObject * obj0 = 0 ;
27173 char *kwnames[] = {
27174 (char *) "self", NULL
27175 };
27176
27177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27179 if (SWIG_arg_fail(1)) SWIG_fail;
27180 {
27181 PyThreadState* __tstate = wxPyBeginAllowThreads();
27182 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27183
27184 wxPyEndAllowThreads(__tstate);
27185 if (PyErr_Occurred()) SWIG_fail;
27186 }
27187 {
27188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27189 }
27190 return resultobj;
27191 fail:
27192 return NULL;
27193 }
27194
27195
27196 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27197 PyObject *resultobj;
27198 wxWindow *arg1 = (wxWindow *) 0 ;
27199 wxWindow *result;
27200 PyObject * obj0 = 0 ;
27201 char *kwnames[] = {
27202 (char *) "self", NULL
27203 };
27204
27205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27207 if (SWIG_arg_fail(1)) SWIG_fail;
27208 {
27209 PyThreadState* __tstate = wxPyBeginAllowThreads();
27210 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27211
27212 wxPyEndAllowThreads(__tstate);
27213 if (PyErr_Occurred()) SWIG_fail;
27214 }
27215 {
27216 resultobj = wxPyMake_wxObject(result, 0);
27217 }
27218 return resultobj;
27219 fail:
27220 return NULL;
27221 }
27222
27223
27224 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27225 PyObject *resultobj;
27226 wxWindow *arg1 = (wxWindow *) 0 ;
27227 wxWindow *arg2 = (wxWindow *) 0 ;
27228 wxWindow *result;
27229 PyObject * obj0 = 0 ;
27230 PyObject * obj1 = 0 ;
27231 char *kwnames[] = {
27232 (char *) "self",(char *) "child", NULL
27233 };
27234
27235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27237 if (SWIG_arg_fail(1)) SWIG_fail;
27238 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27239 if (SWIG_arg_fail(2)) SWIG_fail;
27240 {
27241 PyThreadState* __tstate = wxPyBeginAllowThreads();
27242 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27243
27244 wxPyEndAllowThreads(__tstate);
27245 if (PyErr_Occurred()) SWIG_fail;
27246 }
27247 {
27248 resultobj = wxPyMake_wxObject(result, 0);
27249 }
27250 return resultobj;
27251 fail:
27252 return NULL;
27253 }
27254
27255
27256 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27257 PyObject *resultobj;
27258 wxWindow *arg1 = (wxWindow *) 0 ;
27259 wxWindow *arg2 = (wxWindow *) 0 ;
27260 PyObject * obj0 = 0 ;
27261 PyObject * obj1 = 0 ;
27262 char *kwnames[] = {
27263 (char *) "self",(char *) "win", NULL
27264 };
27265
27266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27268 if (SWIG_arg_fail(1)) SWIG_fail;
27269 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27270 if (SWIG_arg_fail(2)) SWIG_fail;
27271 {
27272 PyThreadState* __tstate = wxPyBeginAllowThreads();
27273 (arg1)->SetTmpDefaultItem(arg2);
27274
27275 wxPyEndAllowThreads(__tstate);
27276 if (PyErr_Occurred()) SWIG_fail;
27277 }
27278 Py_INCREF(Py_None); resultobj = Py_None;
27279 return resultobj;
27280 fail:
27281 return NULL;
27282 }
27283
27284
27285 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27286 PyObject *resultobj;
27287 wxWindow *arg1 = (wxWindow *) 0 ;
27288 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27289 bool result;
27290 PyObject * obj0 = 0 ;
27291 PyObject * obj1 = 0 ;
27292 char *kwnames[] = {
27293 (char *) "self",(char *) "flags", NULL
27294 };
27295
27296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27298 if (SWIG_arg_fail(1)) SWIG_fail;
27299 if (obj1) {
27300 {
27301 arg2 = (int)(SWIG_As_int(obj1));
27302 if (SWIG_arg_fail(2)) SWIG_fail;
27303 }
27304 }
27305 {
27306 PyThreadState* __tstate = wxPyBeginAllowThreads();
27307 result = (bool)(arg1)->Navigate(arg2);
27308
27309 wxPyEndAllowThreads(__tstate);
27310 if (PyErr_Occurred()) SWIG_fail;
27311 }
27312 {
27313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27314 }
27315 return resultobj;
27316 fail:
27317 return NULL;
27318 }
27319
27320
27321 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27322 PyObject *resultobj;
27323 wxWindow *arg1 = (wxWindow *) 0 ;
27324 wxWindow *arg2 = (wxWindow *) 0 ;
27325 PyObject * obj0 = 0 ;
27326 PyObject * obj1 = 0 ;
27327 char *kwnames[] = {
27328 (char *) "self",(char *) "win", NULL
27329 };
27330
27331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27333 if (SWIG_arg_fail(1)) SWIG_fail;
27334 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27335 if (SWIG_arg_fail(2)) SWIG_fail;
27336 {
27337 PyThreadState* __tstate = wxPyBeginAllowThreads();
27338 (arg1)->MoveAfterInTabOrder(arg2);
27339
27340 wxPyEndAllowThreads(__tstate);
27341 if (PyErr_Occurred()) SWIG_fail;
27342 }
27343 Py_INCREF(Py_None); resultobj = Py_None;
27344 return resultobj;
27345 fail:
27346 return NULL;
27347 }
27348
27349
27350 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27351 PyObject *resultobj;
27352 wxWindow *arg1 = (wxWindow *) 0 ;
27353 wxWindow *arg2 = (wxWindow *) 0 ;
27354 PyObject * obj0 = 0 ;
27355 PyObject * obj1 = 0 ;
27356 char *kwnames[] = {
27357 (char *) "self",(char *) "win", NULL
27358 };
27359
27360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27362 if (SWIG_arg_fail(1)) SWIG_fail;
27363 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27364 if (SWIG_arg_fail(2)) SWIG_fail;
27365 {
27366 PyThreadState* __tstate = wxPyBeginAllowThreads();
27367 (arg1)->MoveBeforeInTabOrder(arg2);
27368
27369 wxPyEndAllowThreads(__tstate);
27370 if (PyErr_Occurred()) SWIG_fail;
27371 }
27372 Py_INCREF(Py_None); resultobj = Py_None;
27373 return resultobj;
27374 fail:
27375 return NULL;
27376 }
27377
27378
27379 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27380 PyObject *resultobj;
27381 wxWindow *arg1 = (wxWindow *) 0 ;
27382 PyObject *result;
27383 PyObject * obj0 = 0 ;
27384 char *kwnames[] = {
27385 (char *) "self", NULL
27386 };
27387
27388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27390 if (SWIG_arg_fail(1)) SWIG_fail;
27391 {
27392 PyThreadState* __tstate = wxPyBeginAllowThreads();
27393 result = (PyObject *)wxWindow_GetChildren(arg1);
27394
27395 wxPyEndAllowThreads(__tstate);
27396 if (PyErr_Occurred()) SWIG_fail;
27397 }
27398 resultobj = result;
27399 return resultobj;
27400 fail:
27401 return NULL;
27402 }
27403
27404
27405 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27406 PyObject *resultobj;
27407 wxWindow *arg1 = (wxWindow *) 0 ;
27408 wxWindow *result;
27409 PyObject * obj0 = 0 ;
27410 char *kwnames[] = {
27411 (char *) "self", NULL
27412 };
27413
27414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27416 if (SWIG_arg_fail(1)) SWIG_fail;
27417 {
27418 PyThreadState* __tstate = wxPyBeginAllowThreads();
27419 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27420
27421 wxPyEndAllowThreads(__tstate);
27422 if (PyErr_Occurred()) SWIG_fail;
27423 }
27424 {
27425 resultobj = wxPyMake_wxObject(result, 0);
27426 }
27427 return resultobj;
27428 fail:
27429 return NULL;
27430 }
27431
27432
27433 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27434 PyObject *resultobj;
27435 wxWindow *arg1 = (wxWindow *) 0 ;
27436 wxWindow *result;
27437 PyObject * obj0 = 0 ;
27438 char *kwnames[] = {
27439 (char *) "self", NULL
27440 };
27441
27442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27444 if (SWIG_arg_fail(1)) SWIG_fail;
27445 {
27446 PyThreadState* __tstate = wxPyBeginAllowThreads();
27447 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27448
27449 wxPyEndAllowThreads(__tstate);
27450 if (PyErr_Occurred()) SWIG_fail;
27451 }
27452 {
27453 resultobj = wxPyMake_wxObject(result, 0);
27454 }
27455 return resultobj;
27456 fail:
27457 return NULL;
27458 }
27459
27460
27461 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27462 PyObject *resultobj;
27463 wxWindow *arg1 = (wxWindow *) 0 ;
27464 bool result;
27465 PyObject * obj0 = 0 ;
27466 char *kwnames[] = {
27467 (char *) "self", NULL
27468 };
27469
27470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27472 if (SWIG_arg_fail(1)) SWIG_fail;
27473 {
27474 PyThreadState* __tstate = wxPyBeginAllowThreads();
27475 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
27476
27477 wxPyEndAllowThreads(__tstate);
27478 if (PyErr_Occurred()) SWIG_fail;
27479 }
27480 {
27481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27482 }
27483 return resultobj;
27484 fail:
27485 return NULL;
27486 }
27487
27488
27489 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
27490 PyObject *resultobj;
27491 wxWindow *arg1 = (wxWindow *) 0 ;
27492 wxWindow *arg2 = (wxWindow *) 0 ;
27493 bool result;
27494 PyObject * obj0 = 0 ;
27495 PyObject * obj1 = 0 ;
27496 char *kwnames[] = {
27497 (char *) "self",(char *) "newParent", NULL
27498 };
27499
27500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
27501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27502 if (SWIG_arg_fail(1)) SWIG_fail;
27503 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27504 if (SWIG_arg_fail(2)) SWIG_fail;
27505 {
27506 PyThreadState* __tstate = wxPyBeginAllowThreads();
27507 result = (bool)(arg1)->Reparent(arg2);
27508
27509 wxPyEndAllowThreads(__tstate);
27510 if (PyErr_Occurred()) SWIG_fail;
27511 }
27512 {
27513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27514 }
27515 return resultobj;
27516 fail:
27517 return NULL;
27518 }
27519
27520
27521 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
27522 PyObject *resultobj;
27523 wxWindow *arg1 = (wxWindow *) 0 ;
27524 wxWindow *arg2 = (wxWindow *) 0 ;
27525 PyObject * obj0 = 0 ;
27526 PyObject * obj1 = 0 ;
27527 char *kwnames[] = {
27528 (char *) "self",(char *) "child", NULL
27529 };
27530
27531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
27532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27533 if (SWIG_arg_fail(1)) SWIG_fail;
27534 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27535 if (SWIG_arg_fail(2)) SWIG_fail;
27536 {
27537 PyThreadState* __tstate = wxPyBeginAllowThreads();
27538 (arg1)->AddChild(arg2);
27539
27540 wxPyEndAllowThreads(__tstate);
27541 if (PyErr_Occurred()) SWIG_fail;
27542 }
27543 Py_INCREF(Py_None); resultobj = Py_None;
27544 return resultobj;
27545 fail:
27546 return NULL;
27547 }
27548
27549
27550 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
27551 PyObject *resultobj;
27552 wxWindow *arg1 = (wxWindow *) 0 ;
27553 wxWindow *arg2 = (wxWindow *) 0 ;
27554 PyObject * obj0 = 0 ;
27555 PyObject * obj1 = 0 ;
27556 char *kwnames[] = {
27557 (char *) "self",(char *) "child", NULL
27558 };
27559
27560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
27561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27562 if (SWIG_arg_fail(1)) SWIG_fail;
27563 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27564 if (SWIG_arg_fail(2)) SWIG_fail;
27565 {
27566 PyThreadState* __tstate = wxPyBeginAllowThreads();
27567 (arg1)->RemoveChild(arg2);
27568
27569 wxPyEndAllowThreads(__tstate);
27570 if (PyErr_Occurred()) SWIG_fail;
27571 }
27572 Py_INCREF(Py_None); resultobj = Py_None;
27573 return resultobj;
27574 fail:
27575 return NULL;
27576 }
27577
27578
27579 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
27580 PyObject *resultobj;
27581 wxWindow *arg1 = (wxWindow *) 0 ;
27582 long arg2 ;
27583 wxWindow *result;
27584 PyObject * obj0 = 0 ;
27585 PyObject * obj1 = 0 ;
27586 char *kwnames[] = {
27587 (char *) "self",(char *) "winid", NULL
27588 };
27589
27590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
27591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27592 if (SWIG_arg_fail(1)) SWIG_fail;
27593 {
27594 arg2 = (long)(SWIG_As_long(obj1));
27595 if (SWIG_arg_fail(2)) SWIG_fail;
27596 }
27597 {
27598 PyThreadState* __tstate = wxPyBeginAllowThreads();
27599 result = (wxWindow *)(arg1)->FindWindow(arg2);
27600
27601 wxPyEndAllowThreads(__tstate);
27602 if (PyErr_Occurred()) SWIG_fail;
27603 }
27604 {
27605 resultobj = wxPyMake_wxObject(result, 0);
27606 }
27607 return resultobj;
27608 fail:
27609 return NULL;
27610 }
27611
27612
27613 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
27614 PyObject *resultobj;
27615 wxWindow *arg1 = (wxWindow *) 0 ;
27616 wxString *arg2 = 0 ;
27617 wxWindow *result;
27618 bool temp2 = false ;
27619 PyObject * obj0 = 0 ;
27620 PyObject * obj1 = 0 ;
27621 char *kwnames[] = {
27622 (char *) "self",(char *) "name", NULL
27623 };
27624
27625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
27626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27627 if (SWIG_arg_fail(1)) SWIG_fail;
27628 {
27629 arg2 = wxString_in_helper(obj1);
27630 if (arg2 == NULL) SWIG_fail;
27631 temp2 = true;
27632 }
27633 {
27634 PyThreadState* __tstate = wxPyBeginAllowThreads();
27635 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
27636
27637 wxPyEndAllowThreads(__tstate);
27638 if (PyErr_Occurred()) SWIG_fail;
27639 }
27640 {
27641 resultobj = wxPyMake_wxObject(result, 0);
27642 }
27643 {
27644 if (temp2)
27645 delete arg2;
27646 }
27647 return resultobj;
27648 fail:
27649 {
27650 if (temp2)
27651 delete arg2;
27652 }
27653 return NULL;
27654 }
27655
27656
27657 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27658 PyObject *resultobj;
27659 wxWindow *arg1 = (wxWindow *) 0 ;
27660 wxEvtHandler *result;
27661 PyObject * obj0 = 0 ;
27662 char *kwnames[] = {
27663 (char *) "self", NULL
27664 };
27665
27666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
27667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27668 if (SWIG_arg_fail(1)) SWIG_fail;
27669 {
27670 PyThreadState* __tstate = wxPyBeginAllowThreads();
27671 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
27672
27673 wxPyEndAllowThreads(__tstate);
27674 if (PyErr_Occurred()) SWIG_fail;
27675 }
27676 {
27677 resultobj = wxPyMake_wxObject(result, 0);
27678 }
27679 return resultobj;
27680 fail:
27681 return NULL;
27682 }
27683
27684
27685 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27686 PyObject *resultobj;
27687 wxWindow *arg1 = (wxWindow *) 0 ;
27688 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27689 PyObject * obj0 = 0 ;
27690 PyObject * obj1 = 0 ;
27691 char *kwnames[] = {
27692 (char *) "self",(char *) "handler", NULL
27693 };
27694
27695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
27696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27697 if (SWIG_arg_fail(1)) SWIG_fail;
27698 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27699 if (SWIG_arg_fail(2)) SWIG_fail;
27700 {
27701 PyThreadState* __tstate = wxPyBeginAllowThreads();
27702 (arg1)->SetEventHandler(arg2);
27703
27704 wxPyEndAllowThreads(__tstate);
27705 if (PyErr_Occurred()) SWIG_fail;
27706 }
27707 Py_INCREF(Py_None); resultobj = Py_None;
27708 return resultobj;
27709 fail:
27710 return NULL;
27711 }
27712
27713
27714 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27715 PyObject *resultobj;
27716 wxWindow *arg1 = (wxWindow *) 0 ;
27717 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27718 PyObject * obj0 = 0 ;
27719 PyObject * obj1 = 0 ;
27720 char *kwnames[] = {
27721 (char *) "self",(char *) "handler", NULL
27722 };
27723
27724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
27725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27726 if (SWIG_arg_fail(1)) SWIG_fail;
27727 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27728 if (SWIG_arg_fail(2)) SWIG_fail;
27729 {
27730 PyThreadState* __tstate = wxPyBeginAllowThreads();
27731 (arg1)->PushEventHandler(arg2);
27732
27733 wxPyEndAllowThreads(__tstate);
27734 if (PyErr_Occurred()) SWIG_fail;
27735 }
27736 Py_INCREF(Py_None); resultobj = Py_None;
27737 return resultobj;
27738 fail:
27739 return NULL;
27740 }
27741
27742
27743 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27744 PyObject *resultobj;
27745 wxWindow *arg1 = (wxWindow *) 0 ;
27746 bool arg2 = (bool) false ;
27747 wxEvtHandler *result;
27748 PyObject * obj0 = 0 ;
27749 PyObject * obj1 = 0 ;
27750 char *kwnames[] = {
27751 (char *) "self",(char *) "deleteHandler", NULL
27752 };
27753
27754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
27755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27756 if (SWIG_arg_fail(1)) SWIG_fail;
27757 if (obj1) {
27758 {
27759 arg2 = (bool)(SWIG_As_bool(obj1));
27760 if (SWIG_arg_fail(2)) SWIG_fail;
27761 }
27762 }
27763 {
27764 PyThreadState* __tstate = wxPyBeginAllowThreads();
27765 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
27766
27767 wxPyEndAllowThreads(__tstate);
27768 if (PyErr_Occurred()) SWIG_fail;
27769 }
27770 {
27771 resultobj = wxPyMake_wxObject(result, 0);
27772 }
27773 return resultobj;
27774 fail:
27775 return NULL;
27776 }
27777
27778
27779 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27780 PyObject *resultobj;
27781 wxWindow *arg1 = (wxWindow *) 0 ;
27782 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27783 bool result;
27784 PyObject * obj0 = 0 ;
27785 PyObject * obj1 = 0 ;
27786 char *kwnames[] = {
27787 (char *) "self",(char *) "handler", NULL
27788 };
27789
27790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
27791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27792 if (SWIG_arg_fail(1)) SWIG_fail;
27793 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27794 if (SWIG_arg_fail(2)) SWIG_fail;
27795 {
27796 PyThreadState* __tstate = wxPyBeginAllowThreads();
27797 result = (bool)(arg1)->RemoveEventHandler(arg2);
27798
27799 wxPyEndAllowThreads(__tstate);
27800 if (PyErr_Occurred()) SWIG_fail;
27801 }
27802 {
27803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27804 }
27805 return resultobj;
27806 fail:
27807 return NULL;
27808 }
27809
27810
27811 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
27812 PyObject *resultobj;
27813 wxWindow *arg1 = (wxWindow *) 0 ;
27814 wxValidator *arg2 = 0 ;
27815 PyObject * obj0 = 0 ;
27816 PyObject * obj1 = 0 ;
27817 char *kwnames[] = {
27818 (char *) "self",(char *) "validator", NULL
27819 };
27820
27821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
27822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27823 if (SWIG_arg_fail(1)) SWIG_fail;
27824 {
27825 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
27826 if (SWIG_arg_fail(2)) SWIG_fail;
27827 if (arg2 == NULL) {
27828 SWIG_null_ref("wxValidator");
27829 }
27830 if (SWIG_arg_fail(2)) SWIG_fail;
27831 }
27832 {
27833 PyThreadState* __tstate = wxPyBeginAllowThreads();
27834 (arg1)->SetValidator((wxValidator const &)*arg2);
27835
27836 wxPyEndAllowThreads(__tstate);
27837 if (PyErr_Occurred()) SWIG_fail;
27838 }
27839 Py_INCREF(Py_None); resultobj = Py_None;
27840 return resultobj;
27841 fail:
27842 return NULL;
27843 }
27844
27845
27846 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
27847 PyObject *resultobj;
27848 wxWindow *arg1 = (wxWindow *) 0 ;
27849 wxValidator *result;
27850 PyObject * obj0 = 0 ;
27851 char *kwnames[] = {
27852 (char *) "self", NULL
27853 };
27854
27855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
27856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27857 if (SWIG_arg_fail(1)) SWIG_fail;
27858 {
27859 PyThreadState* __tstate = wxPyBeginAllowThreads();
27860 result = (wxValidator *)(arg1)->GetValidator();
27861
27862 wxPyEndAllowThreads(__tstate);
27863 if (PyErr_Occurred()) SWIG_fail;
27864 }
27865 {
27866 resultobj = wxPyMake_wxObject(result, 0);
27867 }
27868 return resultobj;
27869 fail:
27870 return NULL;
27871 }
27872
27873
27874 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
27875 PyObject *resultobj;
27876 wxWindow *arg1 = (wxWindow *) 0 ;
27877 bool result;
27878 PyObject * obj0 = 0 ;
27879 char *kwnames[] = {
27880 (char *) "self", NULL
27881 };
27882
27883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
27884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27885 if (SWIG_arg_fail(1)) SWIG_fail;
27886 {
27887 PyThreadState* __tstate = wxPyBeginAllowThreads();
27888 result = (bool)(arg1)->Validate();
27889
27890 wxPyEndAllowThreads(__tstate);
27891 if (PyErr_Occurred()) SWIG_fail;
27892 }
27893 {
27894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27895 }
27896 return resultobj;
27897 fail:
27898 return NULL;
27899 }
27900
27901
27902 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
27903 PyObject *resultobj;
27904 wxWindow *arg1 = (wxWindow *) 0 ;
27905 bool result;
27906 PyObject * obj0 = 0 ;
27907 char *kwnames[] = {
27908 (char *) "self", NULL
27909 };
27910
27911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
27912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27913 if (SWIG_arg_fail(1)) SWIG_fail;
27914 {
27915 PyThreadState* __tstate = wxPyBeginAllowThreads();
27916 result = (bool)(arg1)->TransferDataToWindow();
27917
27918 wxPyEndAllowThreads(__tstate);
27919 if (PyErr_Occurred()) SWIG_fail;
27920 }
27921 {
27922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27923 }
27924 return resultobj;
27925 fail:
27926 return NULL;
27927 }
27928
27929
27930 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
27931 PyObject *resultobj;
27932 wxWindow *arg1 = (wxWindow *) 0 ;
27933 bool result;
27934 PyObject * obj0 = 0 ;
27935 char *kwnames[] = {
27936 (char *) "self", NULL
27937 };
27938
27939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
27940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27941 if (SWIG_arg_fail(1)) SWIG_fail;
27942 {
27943 PyThreadState* __tstate = wxPyBeginAllowThreads();
27944 result = (bool)(arg1)->TransferDataFromWindow();
27945
27946 wxPyEndAllowThreads(__tstate);
27947 if (PyErr_Occurred()) SWIG_fail;
27948 }
27949 {
27950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27951 }
27952 return resultobj;
27953 fail:
27954 return NULL;
27955 }
27956
27957
27958 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
27959 PyObject *resultobj;
27960 wxWindow *arg1 = (wxWindow *) 0 ;
27961 PyObject * obj0 = 0 ;
27962 char *kwnames[] = {
27963 (char *) "self", NULL
27964 };
27965
27966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
27967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27968 if (SWIG_arg_fail(1)) SWIG_fail;
27969 {
27970 PyThreadState* __tstate = wxPyBeginAllowThreads();
27971 (arg1)->InitDialog();
27972
27973 wxPyEndAllowThreads(__tstate);
27974 if (PyErr_Occurred()) SWIG_fail;
27975 }
27976 Py_INCREF(Py_None); resultobj = Py_None;
27977 return resultobj;
27978 fail:
27979 return NULL;
27980 }
27981
27982
27983 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
27984 PyObject *resultobj;
27985 wxWindow *arg1 = (wxWindow *) 0 ;
27986 wxAcceleratorTable *arg2 = 0 ;
27987 PyObject * obj0 = 0 ;
27988 PyObject * obj1 = 0 ;
27989 char *kwnames[] = {
27990 (char *) "self",(char *) "accel", NULL
27991 };
27992
27993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
27994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27995 if (SWIG_arg_fail(1)) SWIG_fail;
27996 {
27997 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
27998 if (SWIG_arg_fail(2)) SWIG_fail;
27999 if (arg2 == NULL) {
28000 SWIG_null_ref("wxAcceleratorTable");
28001 }
28002 if (SWIG_arg_fail(2)) SWIG_fail;
28003 }
28004 {
28005 PyThreadState* __tstate = wxPyBeginAllowThreads();
28006 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28007
28008 wxPyEndAllowThreads(__tstate);
28009 if (PyErr_Occurred()) SWIG_fail;
28010 }
28011 Py_INCREF(Py_None); resultobj = Py_None;
28012 return resultobj;
28013 fail:
28014 return NULL;
28015 }
28016
28017
28018 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28019 PyObject *resultobj;
28020 wxWindow *arg1 = (wxWindow *) 0 ;
28021 wxAcceleratorTable *result;
28022 PyObject * obj0 = 0 ;
28023 char *kwnames[] = {
28024 (char *) "self", NULL
28025 };
28026
28027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28029 if (SWIG_arg_fail(1)) SWIG_fail;
28030 {
28031 PyThreadState* __tstate = wxPyBeginAllowThreads();
28032 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28033
28034 wxPyEndAllowThreads(__tstate);
28035 if (PyErr_Occurred()) SWIG_fail;
28036 }
28037 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28038 return resultobj;
28039 fail:
28040 return NULL;
28041 }
28042
28043
28044 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28045 PyObject *resultobj;
28046 wxWindow *arg1 = (wxWindow *) 0 ;
28047 int arg2 ;
28048 int arg3 ;
28049 int arg4 ;
28050 bool result;
28051 PyObject * obj0 = 0 ;
28052 PyObject * obj1 = 0 ;
28053 PyObject * obj2 = 0 ;
28054 PyObject * obj3 = 0 ;
28055 char *kwnames[] = {
28056 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28057 };
28058
28059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28061 if (SWIG_arg_fail(1)) SWIG_fail;
28062 {
28063 arg2 = (int)(SWIG_As_int(obj1));
28064 if (SWIG_arg_fail(2)) SWIG_fail;
28065 }
28066 {
28067 arg3 = (int)(SWIG_As_int(obj2));
28068 if (SWIG_arg_fail(3)) SWIG_fail;
28069 }
28070 {
28071 arg4 = (int)(SWIG_As_int(obj3));
28072 if (SWIG_arg_fail(4)) SWIG_fail;
28073 }
28074 {
28075 PyThreadState* __tstate = wxPyBeginAllowThreads();
28076 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28077
28078 wxPyEndAllowThreads(__tstate);
28079 if (PyErr_Occurred()) SWIG_fail;
28080 }
28081 {
28082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28083 }
28084 return resultobj;
28085 fail:
28086 return NULL;
28087 }
28088
28089
28090 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28091 PyObject *resultobj;
28092 wxWindow *arg1 = (wxWindow *) 0 ;
28093 int arg2 ;
28094 bool result;
28095 PyObject * obj0 = 0 ;
28096 PyObject * obj1 = 0 ;
28097 char *kwnames[] = {
28098 (char *) "self",(char *) "hotkeyId", NULL
28099 };
28100
28101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28103 if (SWIG_arg_fail(1)) SWIG_fail;
28104 {
28105 arg2 = (int)(SWIG_As_int(obj1));
28106 if (SWIG_arg_fail(2)) SWIG_fail;
28107 }
28108 {
28109 PyThreadState* __tstate = wxPyBeginAllowThreads();
28110 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28111
28112 wxPyEndAllowThreads(__tstate);
28113 if (PyErr_Occurred()) SWIG_fail;
28114 }
28115 {
28116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28117 }
28118 return resultobj;
28119 fail:
28120 return NULL;
28121 }
28122
28123
28124 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28125 PyObject *resultobj;
28126 wxWindow *arg1 = (wxWindow *) 0 ;
28127 wxPoint *arg2 = 0 ;
28128 wxPoint result;
28129 wxPoint temp2 ;
28130 PyObject * obj0 = 0 ;
28131 PyObject * obj1 = 0 ;
28132 char *kwnames[] = {
28133 (char *) "self",(char *) "pt", NULL
28134 };
28135
28136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28138 if (SWIG_arg_fail(1)) SWIG_fail;
28139 {
28140 arg2 = &temp2;
28141 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28142 }
28143 {
28144 PyThreadState* __tstate = wxPyBeginAllowThreads();
28145 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28146
28147 wxPyEndAllowThreads(__tstate);
28148 if (PyErr_Occurred()) SWIG_fail;
28149 }
28150 {
28151 wxPoint * resultptr;
28152 resultptr = new wxPoint((wxPoint &)(result));
28153 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28154 }
28155 return resultobj;
28156 fail:
28157 return NULL;
28158 }
28159
28160
28161 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28162 PyObject *resultobj;
28163 wxWindow *arg1 = (wxWindow *) 0 ;
28164 wxSize *arg2 = 0 ;
28165 wxSize result;
28166 wxSize temp2 ;
28167 PyObject * obj0 = 0 ;
28168 PyObject * obj1 = 0 ;
28169 char *kwnames[] = {
28170 (char *) "self",(char *) "sz", NULL
28171 };
28172
28173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28175 if (SWIG_arg_fail(1)) SWIG_fail;
28176 {
28177 arg2 = &temp2;
28178 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28179 }
28180 {
28181 PyThreadState* __tstate = wxPyBeginAllowThreads();
28182 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28183
28184 wxPyEndAllowThreads(__tstate);
28185 if (PyErr_Occurred()) SWIG_fail;
28186 }
28187 {
28188 wxSize * resultptr;
28189 resultptr = new wxSize((wxSize &)(result));
28190 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28191 }
28192 return resultobj;
28193 fail:
28194 return NULL;
28195 }
28196
28197
28198 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28199 PyObject *resultobj;
28200 wxWindow *arg1 = (wxWindow *) 0 ;
28201 wxPoint *arg2 = 0 ;
28202 wxPoint result;
28203 wxPoint temp2 ;
28204 PyObject * obj0 = 0 ;
28205 PyObject * obj1 = 0 ;
28206 char *kwnames[] = {
28207 (char *) "self",(char *) "pt", NULL
28208 };
28209
28210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28212 if (SWIG_arg_fail(1)) SWIG_fail;
28213 {
28214 arg2 = &temp2;
28215 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28216 }
28217 {
28218 PyThreadState* __tstate = wxPyBeginAllowThreads();
28219 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28220
28221 wxPyEndAllowThreads(__tstate);
28222 if (PyErr_Occurred()) SWIG_fail;
28223 }
28224 {
28225 wxPoint * resultptr;
28226 resultptr = new wxPoint((wxPoint &)(result));
28227 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28228 }
28229 return resultobj;
28230 fail:
28231 return NULL;
28232 }
28233
28234
28235 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28236 PyObject *resultobj;
28237 wxWindow *arg1 = (wxWindow *) 0 ;
28238 wxSize *arg2 = 0 ;
28239 wxSize result;
28240 wxSize temp2 ;
28241 PyObject * obj0 = 0 ;
28242 PyObject * obj1 = 0 ;
28243 char *kwnames[] = {
28244 (char *) "self",(char *) "sz", NULL
28245 };
28246
28247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28249 if (SWIG_arg_fail(1)) SWIG_fail;
28250 {
28251 arg2 = &temp2;
28252 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28253 }
28254 {
28255 PyThreadState* __tstate = wxPyBeginAllowThreads();
28256 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28257
28258 wxPyEndAllowThreads(__tstate);
28259 if (PyErr_Occurred()) SWIG_fail;
28260 }
28261 {
28262 wxSize * resultptr;
28263 resultptr = new wxSize((wxSize &)(result));
28264 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28265 }
28266 return resultobj;
28267 fail:
28268 return NULL;
28269 }
28270
28271
28272 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28273 PyObject *resultobj;
28274 wxWindow *arg1 = (wxWindow *) 0 ;
28275 wxPoint *arg2 = 0 ;
28276 wxPoint result;
28277 wxPoint temp2 ;
28278 PyObject * obj0 = 0 ;
28279 PyObject * obj1 = 0 ;
28280 char *kwnames[] = {
28281 (char *) "self",(char *) "pt", NULL
28282 };
28283
28284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28286 if (SWIG_arg_fail(1)) SWIG_fail;
28287 {
28288 arg2 = &temp2;
28289 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28290 }
28291 {
28292 PyThreadState* __tstate = wxPyBeginAllowThreads();
28293 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28294
28295 wxPyEndAllowThreads(__tstate);
28296 if (PyErr_Occurred()) SWIG_fail;
28297 }
28298 {
28299 wxPoint * resultptr;
28300 resultptr = new wxPoint((wxPoint &)(result));
28301 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28302 }
28303 return resultobj;
28304 fail:
28305 return NULL;
28306 }
28307
28308
28309 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28310 PyObject *resultobj;
28311 wxWindow *arg1 = (wxWindow *) 0 ;
28312 wxSize *arg2 = 0 ;
28313 wxSize result;
28314 wxSize temp2 ;
28315 PyObject * obj0 = 0 ;
28316 PyObject * obj1 = 0 ;
28317 char *kwnames[] = {
28318 (char *) "self",(char *) "sz", NULL
28319 };
28320
28321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
28322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28323 if (SWIG_arg_fail(1)) SWIG_fail;
28324 {
28325 arg2 = &temp2;
28326 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28327 }
28328 {
28329 PyThreadState* __tstate = wxPyBeginAllowThreads();
28330 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28331
28332 wxPyEndAllowThreads(__tstate);
28333 if (PyErr_Occurred()) SWIG_fail;
28334 }
28335 {
28336 wxSize * resultptr;
28337 resultptr = new wxSize((wxSize &)(result));
28338 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28339 }
28340 return resultobj;
28341 fail:
28342 return NULL;
28343 }
28344
28345
28346 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28347 PyObject *resultobj;
28348 wxWindow *arg1 = (wxWindow *) 0 ;
28349 int arg2 ;
28350 int arg3 ;
28351 PyObject * obj0 = 0 ;
28352 PyObject * obj1 = 0 ;
28353 PyObject * obj2 = 0 ;
28354 char *kwnames[] = {
28355 (char *) "self",(char *) "x",(char *) "y", NULL
28356 };
28357
28358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28360 if (SWIG_arg_fail(1)) SWIG_fail;
28361 {
28362 arg2 = (int)(SWIG_As_int(obj1));
28363 if (SWIG_arg_fail(2)) SWIG_fail;
28364 }
28365 {
28366 arg3 = (int)(SWIG_As_int(obj2));
28367 if (SWIG_arg_fail(3)) SWIG_fail;
28368 }
28369 {
28370 PyThreadState* __tstate = wxPyBeginAllowThreads();
28371 (arg1)->WarpPointer(arg2,arg3);
28372
28373 wxPyEndAllowThreads(__tstate);
28374 if (PyErr_Occurred()) SWIG_fail;
28375 }
28376 Py_INCREF(Py_None); resultobj = Py_None;
28377 return resultobj;
28378 fail:
28379 return NULL;
28380 }
28381
28382
28383 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28384 PyObject *resultobj;
28385 wxWindow *arg1 = (wxWindow *) 0 ;
28386 PyObject * obj0 = 0 ;
28387 char *kwnames[] = {
28388 (char *) "self", NULL
28389 };
28390
28391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28393 if (SWIG_arg_fail(1)) SWIG_fail;
28394 {
28395 PyThreadState* __tstate = wxPyBeginAllowThreads();
28396 (arg1)->CaptureMouse();
28397
28398 wxPyEndAllowThreads(__tstate);
28399 if (PyErr_Occurred()) SWIG_fail;
28400 }
28401 Py_INCREF(Py_None); resultobj = Py_None;
28402 return resultobj;
28403 fail:
28404 return NULL;
28405 }
28406
28407
28408 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28409 PyObject *resultobj;
28410 wxWindow *arg1 = (wxWindow *) 0 ;
28411 PyObject * obj0 = 0 ;
28412 char *kwnames[] = {
28413 (char *) "self", NULL
28414 };
28415
28416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28418 if (SWIG_arg_fail(1)) SWIG_fail;
28419 {
28420 PyThreadState* __tstate = wxPyBeginAllowThreads();
28421 (arg1)->ReleaseMouse();
28422
28423 wxPyEndAllowThreads(__tstate);
28424 if (PyErr_Occurred()) SWIG_fail;
28425 }
28426 Py_INCREF(Py_None); resultobj = Py_None;
28427 return resultobj;
28428 fail:
28429 return NULL;
28430 }
28431
28432
28433 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28434 PyObject *resultobj;
28435 wxWindow *result;
28436 char *kwnames[] = {
28437 NULL
28438 };
28439
28440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28441 {
28442 if (!wxPyCheckForApp()) SWIG_fail;
28443 PyThreadState* __tstate = wxPyBeginAllowThreads();
28444 result = (wxWindow *)wxWindow::GetCapture();
28445
28446 wxPyEndAllowThreads(__tstate);
28447 if (PyErr_Occurred()) SWIG_fail;
28448 }
28449 {
28450 resultobj = wxPyMake_wxObject(result, 0);
28451 }
28452 return resultobj;
28453 fail:
28454 return NULL;
28455 }
28456
28457
28458 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28459 PyObject *resultobj;
28460 wxWindow *arg1 = (wxWindow *) 0 ;
28461 bool result;
28462 PyObject * obj0 = 0 ;
28463 char *kwnames[] = {
28464 (char *) "self", NULL
28465 };
28466
28467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28469 if (SWIG_arg_fail(1)) SWIG_fail;
28470 {
28471 PyThreadState* __tstate = wxPyBeginAllowThreads();
28472 result = (bool)((wxWindow const *)arg1)->HasCapture();
28473
28474 wxPyEndAllowThreads(__tstate);
28475 if (PyErr_Occurred()) SWIG_fail;
28476 }
28477 {
28478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28479 }
28480 return resultobj;
28481 fail:
28482 return NULL;
28483 }
28484
28485
28486 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
28487 PyObject *resultobj;
28488 wxWindow *arg1 = (wxWindow *) 0 ;
28489 bool arg2 = (bool) true ;
28490 wxRect *arg3 = (wxRect *) NULL ;
28491 PyObject * obj0 = 0 ;
28492 PyObject * obj1 = 0 ;
28493 PyObject * obj2 = 0 ;
28494 char *kwnames[] = {
28495 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
28496 };
28497
28498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
28499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28500 if (SWIG_arg_fail(1)) SWIG_fail;
28501 if (obj1) {
28502 {
28503 arg2 = (bool)(SWIG_As_bool(obj1));
28504 if (SWIG_arg_fail(2)) SWIG_fail;
28505 }
28506 }
28507 if (obj2) {
28508 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
28509 if (SWIG_arg_fail(3)) SWIG_fail;
28510 }
28511 {
28512 PyThreadState* __tstate = wxPyBeginAllowThreads();
28513 (arg1)->Refresh(arg2,(wxRect const *)arg3);
28514
28515 wxPyEndAllowThreads(__tstate);
28516 if (PyErr_Occurred()) SWIG_fail;
28517 }
28518 Py_INCREF(Py_None); resultobj = Py_None;
28519 return resultobj;
28520 fail:
28521 return NULL;
28522 }
28523
28524
28525 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
28526 PyObject *resultobj;
28527 wxWindow *arg1 = (wxWindow *) 0 ;
28528 wxRect *arg2 = 0 ;
28529 bool arg3 = (bool) true ;
28530 wxRect temp2 ;
28531 PyObject * obj0 = 0 ;
28532 PyObject * obj1 = 0 ;
28533 PyObject * obj2 = 0 ;
28534 char *kwnames[] = {
28535 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
28536 };
28537
28538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
28539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28540 if (SWIG_arg_fail(1)) SWIG_fail;
28541 {
28542 arg2 = &temp2;
28543 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28544 }
28545 if (obj2) {
28546 {
28547 arg3 = (bool)(SWIG_As_bool(obj2));
28548 if (SWIG_arg_fail(3)) SWIG_fail;
28549 }
28550 }
28551 {
28552 PyThreadState* __tstate = wxPyBeginAllowThreads();
28553 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
28554
28555 wxPyEndAllowThreads(__tstate);
28556 if (PyErr_Occurred()) SWIG_fail;
28557 }
28558 Py_INCREF(Py_None); resultobj = Py_None;
28559 return resultobj;
28560 fail:
28561 return NULL;
28562 }
28563
28564
28565 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
28566 PyObject *resultobj;
28567 wxWindow *arg1 = (wxWindow *) 0 ;
28568 PyObject * obj0 = 0 ;
28569 char *kwnames[] = {
28570 (char *) "self", NULL
28571 };
28572
28573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
28574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28575 if (SWIG_arg_fail(1)) SWIG_fail;
28576 {
28577 PyThreadState* __tstate = wxPyBeginAllowThreads();
28578 (arg1)->Update();
28579
28580 wxPyEndAllowThreads(__tstate);
28581 if (PyErr_Occurred()) SWIG_fail;
28582 }
28583 Py_INCREF(Py_None); resultobj = Py_None;
28584 return resultobj;
28585 fail:
28586 return NULL;
28587 }
28588
28589
28590 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
28591 PyObject *resultobj;
28592 wxWindow *arg1 = (wxWindow *) 0 ;
28593 PyObject * obj0 = 0 ;
28594 char *kwnames[] = {
28595 (char *) "self", NULL
28596 };
28597
28598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
28599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28600 if (SWIG_arg_fail(1)) SWIG_fail;
28601 {
28602 PyThreadState* __tstate = wxPyBeginAllowThreads();
28603 (arg1)->ClearBackground();
28604
28605 wxPyEndAllowThreads(__tstate);
28606 if (PyErr_Occurred()) SWIG_fail;
28607 }
28608 Py_INCREF(Py_None); resultobj = Py_None;
28609 return resultobj;
28610 fail:
28611 return NULL;
28612 }
28613
28614
28615 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
28616 PyObject *resultobj;
28617 wxWindow *arg1 = (wxWindow *) 0 ;
28618 PyObject * obj0 = 0 ;
28619 char *kwnames[] = {
28620 (char *) "self", NULL
28621 };
28622
28623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
28624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28625 if (SWIG_arg_fail(1)) SWIG_fail;
28626 {
28627 PyThreadState* __tstate = wxPyBeginAllowThreads();
28628 (arg1)->Freeze();
28629
28630 wxPyEndAllowThreads(__tstate);
28631 if (PyErr_Occurred()) SWIG_fail;
28632 }
28633 Py_INCREF(Py_None); resultobj = Py_None;
28634 return resultobj;
28635 fail:
28636 return NULL;
28637 }
28638
28639
28640 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
28641 PyObject *resultobj;
28642 wxWindow *arg1 = (wxWindow *) 0 ;
28643 PyObject * obj0 = 0 ;
28644 char *kwnames[] = {
28645 (char *) "self", NULL
28646 };
28647
28648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
28649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28650 if (SWIG_arg_fail(1)) SWIG_fail;
28651 {
28652 PyThreadState* __tstate = wxPyBeginAllowThreads();
28653 (arg1)->Thaw();
28654
28655 wxPyEndAllowThreads(__tstate);
28656 if (PyErr_Occurred()) SWIG_fail;
28657 }
28658 Py_INCREF(Py_None); resultobj = Py_None;
28659 return resultobj;
28660 fail:
28661 return NULL;
28662 }
28663
28664
28665 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
28666 PyObject *resultobj;
28667 wxWindow *arg1 = (wxWindow *) 0 ;
28668 wxDC *arg2 = 0 ;
28669 PyObject * obj0 = 0 ;
28670 PyObject * obj1 = 0 ;
28671 char *kwnames[] = {
28672 (char *) "self",(char *) "dc", NULL
28673 };
28674
28675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
28676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28677 if (SWIG_arg_fail(1)) SWIG_fail;
28678 {
28679 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
28680 if (SWIG_arg_fail(2)) SWIG_fail;
28681 if (arg2 == NULL) {
28682 SWIG_null_ref("wxDC");
28683 }
28684 if (SWIG_arg_fail(2)) SWIG_fail;
28685 }
28686 {
28687 PyThreadState* __tstate = wxPyBeginAllowThreads();
28688 (arg1)->PrepareDC(*arg2);
28689
28690 wxPyEndAllowThreads(__tstate);
28691 if (PyErr_Occurred()) SWIG_fail;
28692 }
28693 Py_INCREF(Py_None); resultobj = Py_None;
28694 return resultobj;
28695 fail:
28696 return NULL;
28697 }
28698
28699
28700 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
28701 PyObject *resultobj;
28702 wxWindow *arg1 = (wxWindow *) 0 ;
28703 wxRegion *result;
28704 PyObject * obj0 = 0 ;
28705 char *kwnames[] = {
28706 (char *) "self", NULL
28707 };
28708
28709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
28710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28711 if (SWIG_arg_fail(1)) SWIG_fail;
28712 {
28713 PyThreadState* __tstate = wxPyBeginAllowThreads();
28714 {
28715 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
28716 result = (wxRegion *) &_result_ref;
28717 }
28718
28719 wxPyEndAllowThreads(__tstate);
28720 if (PyErr_Occurred()) SWIG_fail;
28721 }
28722 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
28723 return resultobj;
28724 fail:
28725 return NULL;
28726 }
28727
28728
28729 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
28730 PyObject *resultobj;
28731 wxWindow *arg1 = (wxWindow *) 0 ;
28732 wxRect result;
28733 PyObject * obj0 = 0 ;
28734 char *kwnames[] = {
28735 (char *) "self", NULL
28736 };
28737
28738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
28739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28740 if (SWIG_arg_fail(1)) SWIG_fail;
28741 {
28742 PyThreadState* __tstate = wxPyBeginAllowThreads();
28743 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
28744
28745 wxPyEndAllowThreads(__tstate);
28746 if (PyErr_Occurred()) SWIG_fail;
28747 }
28748 {
28749 wxRect * resultptr;
28750 resultptr = new wxRect((wxRect &)(result));
28751 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
28752 }
28753 return resultobj;
28754 fail:
28755 return NULL;
28756 }
28757
28758
28759 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
28760 PyObject *resultobj;
28761 wxWindow *arg1 = (wxWindow *) 0 ;
28762 int arg2 ;
28763 int arg3 ;
28764 int arg4 = (int) 1 ;
28765 int arg5 = (int) 1 ;
28766 bool result;
28767 PyObject * obj0 = 0 ;
28768 PyObject * obj1 = 0 ;
28769 PyObject * obj2 = 0 ;
28770 PyObject * obj3 = 0 ;
28771 PyObject * obj4 = 0 ;
28772 char *kwnames[] = {
28773 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
28774 };
28775
28776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
28777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28778 if (SWIG_arg_fail(1)) SWIG_fail;
28779 {
28780 arg2 = (int)(SWIG_As_int(obj1));
28781 if (SWIG_arg_fail(2)) SWIG_fail;
28782 }
28783 {
28784 arg3 = (int)(SWIG_As_int(obj2));
28785 if (SWIG_arg_fail(3)) SWIG_fail;
28786 }
28787 if (obj3) {
28788 {
28789 arg4 = (int)(SWIG_As_int(obj3));
28790 if (SWIG_arg_fail(4)) SWIG_fail;
28791 }
28792 }
28793 if (obj4) {
28794 {
28795 arg5 = (int)(SWIG_As_int(obj4));
28796 if (SWIG_arg_fail(5)) SWIG_fail;
28797 }
28798 }
28799 {
28800 PyThreadState* __tstate = wxPyBeginAllowThreads();
28801 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
28802
28803 wxPyEndAllowThreads(__tstate);
28804 if (PyErr_Occurred()) SWIG_fail;
28805 }
28806 {
28807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28808 }
28809 return resultobj;
28810 fail:
28811 return NULL;
28812 }
28813
28814
28815 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
28816 PyObject *resultobj;
28817 wxWindow *arg1 = (wxWindow *) 0 ;
28818 wxPoint *arg2 = 0 ;
28819 bool result;
28820 wxPoint temp2 ;
28821 PyObject * obj0 = 0 ;
28822 PyObject * obj1 = 0 ;
28823 char *kwnames[] = {
28824 (char *) "self",(char *) "pt", NULL
28825 };
28826
28827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
28828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28829 if (SWIG_arg_fail(1)) SWIG_fail;
28830 {
28831 arg2 = &temp2;
28832 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28833 }
28834 {
28835 PyThreadState* __tstate = wxPyBeginAllowThreads();
28836 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
28837
28838 wxPyEndAllowThreads(__tstate);
28839 if (PyErr_Occurred()) SWIG_fail;
28840 }
28841 {
28842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28843 }
28844 return resultobj;
28845 fail:
28846 return NULL;
28847 }
28848
28849
28850 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
28851 PyObject *resultobj;
28852 wxWindow *arg1 = (wxWindow *) 0 ;
28853 wxRect *arg2 = 0 ;
28854 bool result;
28855 wxRect temp2 ;
28856 PyObject * obj0 = 0 ;
28857 PyObject * obj1 = 0 ;
28858 char *kwnames[] = {
28859 (char *) "self",(char *) "rect", NULL
28860 };
28861
28862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
28863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28864 if (SWIG_arg_fail(1)) SWIG_fail;
28865 {
28866 arg2 = &temp2;
28867 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28868 }
28869 {
28870 PyThreadState* __tstate = wxPyBeginAllowThreads();
28871 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
28872
28873 wxPyEndAllowThreads(__tstate);
28874 if (PyErr_Occurred()) SWIG_fail;
28875 }
28876 {
28877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28878 }
28879 return resultobj;
28880 fail:
28881 return NULL;
28882 }
28883
28884
28885 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
28886 PyObject *resultobj;
28887 wxWindow *arg1 = (wxWindow *) 0 ;
28888 wxVisualAttributes result;
28889 PyObject * obj0 = 0 ;
28890 char *kwnames[] = {
28891 (char *) "self", NULL
28892 };
28893
28894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
28895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28896 if (SWIG_arg_fail(1)) SWIG_fail;
28897 {
28898 PyThreadState* __tstate = wxPyBeginAllowThreads();
28899 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
28900
28901 wxPyEndAllowThreads(__tstate);
28902 if (PyErr_Occurred()) SWIG_fail;
28903 }
28904 {
28905 wxVisualAttributes * resultptr;
28906 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
28907 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
28908 }
28909 return resultobj;
28910 fail:
28911 return NULL;
28912 }
28913
28914
28915 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
28916 PyObject *resultobj;
28917 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
28918 wxVisualAttributes result;
28919 PyObject * obj0 = 0 ;
28920 char *kwnames[] = {
28921 (char *) "variant", NULL
28922 };
28923
28924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
28925 if (obj0) {
28926 {
28927 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
28928 if (SWIG_arg_fail(1)) SWIG_fail;
28929 }
28930 }
28931 {
28932 if (!wxPyCheckForApp()) SWIG_fail;
28933 PyThreadState* __tstate = wxPyBeginAllowThreads();
28934 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
28935
28936 wxPyEndAllowThreads(__tstate);
28937 if (PyErr_Occurred()) SWIG_fail;
28938 }
28939 {
28940 wxVisualAttributes * resultptr;
28941 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
28942 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
28943 }
28944 return resultobj;
28945 fail:
28946 return NULL;
28947 }
28948
28949
28950 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28951 PyObject *resultobj;
28952 wxWindow *arg1 = (wxWindow *) 0 ;
28953 wxColour *arg2 = 0 ;
28954 bool result;
28955 wxColour temp2 ;
28956 PyObject * obj0 = 0 ;
28957 PyObject * obj1 = 0 ;
28958 char *kwnames[] = {
28959 (char *) "self",(char *) "colour", NULL
28960 };
28961
28962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
28963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28964 if (SWIG_arg_fail(1)) SWIG_fail;
28965 {
28966 arg2 = &temp2;
28967 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
28968 }
28969 {
28970 PyThreadState* __tstate = wxPyBeginAllowThreads();
28971 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
28972
28973 wxPyEndAllowThreads(__tstate);
28974 if (PyErr_Occurred()) SWIG_fail;
28975 }
28976 {
28977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28978 }
28979 return resultobj;
28980 fail:
28981 return NULL;
28982 }
28983
28984
28985 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28986 PyObject *resultobj;
28987 wxWindow *arg1 = (wxWindow *) 0 ;
28988 wxColour *arg2 = 0 ;
28989 wxColour temp2 ;
28990 PyObject * obj0 = 0 ;
28991 PyObject * obj1 = 0 ;
28992 char *kwnames[] = {
28993 (char *) "self",(char *) "colour", NULL
28994 };
28995
28996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
28997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28998 if (SWIG_arg_fail(1)) SWIG_fail;
28999 {
29000 arg2 = &temp2;
29001 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29002 }
29003 {
29004 PyThreadState* __tstate = wxPyBeginAllowThreads();
29005 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29006
29007 wxPyEndAllowThreads(__tstate);
29008 if (PyErr_Occurred()) SWIG_fail;
29009 }
29010 Py_INCREF(Py_None); resultobj = Py_None;
29011 return resultobj;
29012 fail:
29013 return NULL;
29014 }
29015
29016
29017 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29018 PyObject *resultobj;
29019 wxWindow *arg1 = (wxWindow *) 0 ;
29020 wxColour *arg2 = 0 ;
29021 bool result;
29022 wxColour temp2 ;
29023 PyObject * obj0 = 0 ;
29024 PyObject * obj1 = 0 ;
29025 char *kwnames[] = {
29026 (char *) "self",(char *) "colour", NULL
29027 };
29028
29029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29031 if (SWIG_arg_fail(1)) SWIG_fail;
29032 {
29033 arg2 = &temp2;
29034 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29035 }
29036 {
29037 PyThreadState* __tstate = wxPyBeginAllowThreads();
29038 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29039
29040 wxPyEndAllowThreads(__tstate);
29041 if (PyErr_Occurred()) SWIG_fail;
29042 }
29043 {
29044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29045 }
29046 return resultobj;
29047 fail:
29048 return NULL;
29049 }
29050
29051
29052 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29053 PyObject *resultobj;
29054 wxWindow *arg1 = (wxWindow *) 0 ;
29055 wxColour *arg2 = 0 ;
29056 wxColour temp2 ;
29057 PyObject * obj0 = 0 ;
29058 PyObject * obj1 = 0 ;
29059 char *kwnames[] = {
29060 (char *) "self",(char *) "colour", NULL
29061 };
29062
29063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29065 if (SWIG_arg_fail(1)) SWIG_fail;
29066 {
29067 arg2 = &temp2;
29068 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29069 }
29070 {
29071 PyThreadState* __tstate = wxPyBeginAllowThreads();
29072 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29073
29074 wxPyEndAllowThreads(__tstate);
29075 if (PyErr_Occurred()) SWIG_fail;
29076 }
29077 Py_INCREF(Py_None); resultobj = Py_None;
29078 return resultobj;
29079 fail:
29080 return NULL;
29081 }
29082
29083
29084 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29085 PyObject *resultobj;
29086 wxWindow *arg1 = (wxWindow *) 0 ;
29087 wxColour result;
29088 PyObject * obj0 = 0 ;
29089 char *kwnames[] = {
29090 (char *) "self", NULL
29091 };
29092
29093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29095 if (SWIG_arg_fail(1)) SWIG_fail;
29096 {
29097 PyThreadState* __tstate = wxPyBeginAllowThreads();
29098 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29099
29100 wxPyEndAllowThreads(__tstate);
29101 if (PyErr_Occurred()) SWIG_fail;
29102 }
29103 {
29104 wxColour * resultptr;
29105 resultptr = new wxColour((wxColour &)(result));
29106 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29107 }
29108 return resultobj;
29109 fail:
29110 return NULL;
29111 }
29112
29113
29114 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29115 PyObject *resultobj;
29116 wxWindow *arg1 = (wxWindow *) 0 ;
29117 wxColour result;
29118 PyObject * obj0 = 0 ;
29119 char *kwnames[] = {
29120 (char *) "self", NULL
29121 };
29122
29123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29125 if (SWIG_arg_fail(1)) SWIG_fail;
29126 {
29127 PyThreadState* __tstate = wxPyBeginAllowThreads();
29128 result = ((wxWindow const *)arg1)->GetForegroundColour();
29129
29130 wxPyEndAllowThreads(__tstate);
29131 if (PyErr_Occurred()) SWIG_fail;
29132 }
29133 {
29134 wxColour * resultptr;
29135 resultptr = new wxColour((wxColour &)(result));
29136 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29137 }
29138 return resultobj;
29139 fail:
29140 return NULL;
29141 }
29142
29143
29144 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29145 PyObject *resultobj;
29146 wxWindow *arg1 = (wxWindow *) 0 ;
29147 wxBackgroundStyle arg2 ;
29148 bool result;
29149 PyObject * obj0 = 0 ;
29150 PyObject * obj1 = 0 ;
29151 char *kwnames[] = {
29152 (char *) "self",(char *) "style", NULL
29153 };
29154
29155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29157 if (SWIG_arg_fail(1)) SWIG_fail;
29158 {
29159 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29160 if (SWIG_arg_fail(2)) SWIG_fail;
29161 }
29162 {
29163 PyThreadState* __tstate = wxPyBeginAllowThreads();
29164 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29165
29166 wxPyEndAllowThreads(__tstate);
29167 if (PyErr_Occurred()) SWIG_fail;
29168 }
29169 {
29170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29171 }
29172 return resultobj;
29173 fail:
29174 return NULL;
29175 }
29176
29177
29178 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29179 PyObject *resultobj;
29180 wxWindow *arg1 = (wxWindow *) 0 ;
29181 wxBackgroundStyle result;
29182 PyObject * obj0 = 0 ;
29183 char *kwnames[] = {
29184 (char *) "self", NULL
29185 };
29186
29187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29189 if (SWIG_arg_fail(1)) SWIG_fail;
29190 {
29191 PyThreadState* __tstate = wxPyBeginAllowThreads();
29192 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29193
29194 wxPyEndAllowThreads(__tstate);
29195 if (PyErr_Occurred()) SWIG_fail;
29196 }
29197 resultobj = SWIG_From_int((result));
29198 return resultobj;
29199 fail:
29200 return NULL;
29201 }
29202
29203
29204 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29205 PyObject *resultobj;
29206 wxWindow *arg1 = (wxWindow *) 0 ;
29207 bool result;
29208 PyObject * obj0 = 0 ;
29209 char *kwnames[] = {
29210 (char *) "self", NULL
29211 };
29212
29213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29215 if (SWIG_arg_fail(1)) SWIG_fail;
29216 {
29217 PyThreadState* __tstate = wxPyBeginAllowThreads();
29218 result = (bool)(arg1)->HasTransparentBackground();
29219
29220 wxPyEndAllowThreads(__tstate);
29221 if (PyErr_Occurred()) SWIG_fail;
29222 }
29223 {
29224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29225 }
29226 return resultobj;
29227 fail:
29228 return NULL;
29229 }
29230
29231
29232 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29233 PyObject *resultobj;
29234 wxWindow *arg1 = (wxWindow *) 0 ;
29235 wxCursor *arg2 = 0 ;
29236 bool result;
29237 PyObject * obj0 = 0 ;
29238 PyObject * obj1 = 0 ;
29239 char *kwnames[] = {
29240 (char *) "self",(char *) "cursor", NULL
29241 };
29242
29243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29245 if (SWIG_arg_fail(1)) SWIG_fail;
29246 {
29247 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29248 if (SWIG_arg_fail(2)) SWIG_fail;
29249 if (arg2 == NULL) {
29250 SWIG_null_ref("wxCursor");
29251 }
29252 if (SWIG_arg_fail(2)) SWIG_fail;
29253 }
29254 {
29255 PyThreadState* __tstate = wxPyBeginAllowThreads();
29256 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29257
29258 wxPyEndAllowThreads(__tstate);
29259 if (PyErr_Occurred()) SWIG_fail;
29260 }
29261 {
29262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29263 }
29264 return resultobj;
29265 fail:
29266 return NULL;
29267 }
29268
29269
29270 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29271 PyObject *resultobj;
29272 wxWindow *arg1 = (wxWindow *) 0 ;
29273 wxCursor result;
29274 PyObject * obj0 = 0 ;
29275 char *kwnames[] = {
29276 (char *) "self", NULL
29277 };
29278
29279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29281 if (SWIG_arg_fail(1)) SWIG_fail;
29282 {
29283 PyThreadState* __tstate = wxPyBeginAllowThreads();
29284 result = (arg1)->GetCursor();
29285
29286 wxPyEndAllowThreads(__tstate);
29287 if (PyErr_Occurred()) SWIG_fail;
29288 }
29289 {
29290 wxCursor * resultptr;
29291 resultptr = new wxCursor((wxCursor &)(result));
29292 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29293 }
29294 return resultobj;
29295 fail:
29296 return NULL;
29297 }
29298
29299
29300 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29301 PyObject *resultobj;
29302 wxWindow *arg1 = (wxWindow *) 0 ;
29303 wxFont *arg2 = 0 ;
29304 bool result;
29305 PyObject * obj0 = 0 ;
29306 PyObject * obj1 = 0 ;
29307 char *kwnames[] = {
29308 (char *) "self",(char *) "font", NULL
29309 };
29310
29311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29313 if (SWIG_arg_fail(1)) SWIG_fail;
29314 {
29315 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29316 if (SWIG_arg_fail(2)) SWIG_fail;
29317 if (arg2 == NULL) {
29318 SWIG_null_ref("wxFont");
29319 }
29320 if (SWIG_arg_fail(2)) SWIG_fail;
29321 }
29322 {
29323 PyThreadState* __tstate = wxPyBeginAllowThreads();
29324 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29325
29326 wxPyEndAllowThreads(__tstate);
29327 if (PyErr_Occurred()) SWIG_fail;
29328 }
29329 {
29330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29331 }
29332 return resultobj;
29333 fail:
29334 return NULL;
29335 }
29336
29337
29338 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29339 PyObject *resultobj;
29340 wxWindow *arg1 = (wxWindow *) 0 ;
29341 wxFont *arg2 = 0 ;
29342 PyObject * obj0 = 0 ;
29343 PyObject * obj1 = 0 ;
29344 char *kwnames[] = {
29345 (char *) "self",(char *) "font", NULL
29346 };
29347
29348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29350 if (SWIG_arg_fail(1)) SWIG_fail;
29351 {
29352 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29353 if (SWIG_arg_fail(2)) SWIG_fail;
29354 if (arg2 == NULL) {
29355 SWIG_null_ref("wxFont");
29356 }
29357 if (SWIG_arg_fail(2)) SWIG_fail;
29358 }
29359 {
29360 PyThreadState* __tstate = wxPyBeginAllowThreads();
29361 (arg1)->SetOwnFont((wxFont const &)*arg2);
29362
29363 wxPyEndAllowThreads(__tstate);
29364 if (PyErr_Occurred()) SWIG_fail;
29365 }
29366 Py_INCREF(Py_None); resultobj = Py_None;
29367 return resultobj;
29368 fail:
29369 return NULL;
29370 }
29371
29372
29373 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29374 PyObject *resultobj;
29375 wxWindow *arg1 = (wxWindow *) 0 ;
29376 wxFont result;
29377 PyObject * obj0 = 0 ;
29378 char *kwnames[] = {
29379 (char *) "self", NULL
29380 };
29381
29382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29384 if (SWIG_arg_fail(1)) SWIG_fail;
29385 {
29386 PyThreadState* __tstate = wxPyBeginAllowThreads();
29387 result = (arg1)->GetFont();
29388
29389 wxPyEndAllowThreads(__tstate);
29390 if (PyErr_Occurred()) SWIG_fail;
29391 }
29392 {
29393 wxFont * resultptr;
29394 resultptr = new wxFont((wxFont &)(result));
29395 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29396 }
29397 return resultobj;
29398 fail:
29399 return NULL;
29400 }
29401
29402
29403 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29404 PyObject *resultobj;
29405 wxWindow *arg1 = (wxWindow *) 0 ;
29406 wxCaret *arg2 = (wxCaret *) 0 ;
29407 PyObject * obj0 = 0 ;
29408 PyObject * obj1 = 0 ;
29409 char *kwnames[] = {
29410 (char *) "self",(char *) "caret", NULL
29411 };
29412
29413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
29417 if (SWIG_arg_fail(2)) SWIG_fail;
29418 {
29419 PyThreadState* __tstate = wxPyBeginAllowThreads();
29420 (arg1)->SetCaret(arg2);
29421
29422 wxPyEndAllowThreads(__tstate);
29423 if (PyErr_Occurred()) SWIG_fail;
29424 }
29425 Py_INCREF(Py_None); resultobj = Py_None;
29426 return resultobj;
29427 fail:
29428 return NULL;
29429 }
29430
29431
29432 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29433 PyObject *resultobj;
29434 wxWindow *arg1 = (wxWindow *) 0 ;
29435 wxCaret *result;
29436 PyObject * obj0 = 0 ;
29437 char *kwnames[] = {
29438 (char *) "self", NULL
29439 };
29440
29441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",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 = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
29447
29448 wxPyEndAllowThreads(__tstate);
29449 if (PyErr_Occurred()) SWIG_fail;
29450 }
29451 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
29452 return resultobj;
29453 fail:
29454 return NULL;
29455 }
29456
29457
29458 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29459 PyObject *resultobj;
29460 wxWindow *arg1 = (wxWindow *) 0 ;
29461 int result;
29462 PyObject * obj0 = 0 ;
29463 char *kwnames[] = {
29464 (char *) "self", NULL
29465 };
29466
29467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
29468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29469 if (SWIG_arg_fail(1)) SWIG_fail;
29470 {
29471 PyThreadState* __tstate = wxPyBeginAllowThreads();
29472 result = (int)((wxWindow const *)arg1)->GetCharHeight();
29473
29474 wxPyEndAllowThreads(__tstate);
29475 if (PyErr_Occurred()) SWIG_fail;
29476 }
29477 {
29478 resultobj = SWIG_From_int((int)(result));
29479 }
29480 return resultobj;
29481 fail:
29482 return NULL;
29483 }
29484
29485
29486 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29487 PyObject *resultobj;
29488 wxWindow *arg1 = (wxWindow *) 0 ;
29489 int result;
29490 PyObject * obj0 = 0 ;
29491 char *kwnames[] = {
29492 (char *) "self", NULL
29493 };
29494
29495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
29496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29497 if (SWIG_arg_fail(1)) SWIG_fail;
29498 {
29499 PyThreadState* __tstate = wxPyBeginAllowThreads();
29500 result = (int)((wxWindow const *)arg1)->GetCharWidth();
29501
29502 wxPyEndAllowThreads(__tstate);
29503 if (PyErr_Occurred()) SWIG_fail;
29504 }
29505 {
29506 resultobj = SWIG_From_int((int)(result));
29507 }
29508 return resultobj;
29509 fail:
29510 return NULL;
29511 }
29512
29513
29514 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29515 PyObject *resultobj;
29516 wxWindow *arg1 = (wxWindow *) 0 ;
29517 wxString *arg2 = 0 ;
29518 int *arg3 = (int *) 0 ;
29519 int *arg4 = (int *) 0 ;
29520 bool temp2 = false ;
29521 int temp3 ;
29522 int res3 = 0 ;
29523 int temp4 ;
29524 int res4 = 0 ;
29525 PyObject * obj0 = 0 ;
29526 PyObject * obj1 = 0 ;
29527 char *kwnames[] = {
29528 (char *) "self",(char *) "string", NULL
29529 };
29530
29531 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29532 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
29534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29535 if (SWIG_arg_fail(1)) SWIG_fail;
29536 {
29537 arg2 = wxString_in_helper(obj1);
29538 if (arg2 == NULL) SWIG_fail;
29539 temp2 = true;
29540 }
29541 {
29542 PyThreadState* __tstate = wxPyBeginAllowThreads();
29543 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
29544
29545 wxPyEndAllowThreads(__tstate);
29546 if (PyErr_Occurred()) SWIG_fail;
29547 }
29548 Py_INCREF(Py_None); resultobj = Py_None;
29549 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29550 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29551 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29552 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29553 {
29554 if (temp2)
29555 delete arg2;
29556 }
29557 return resultobj;
29558 fail:
29559 {
29560 if (temp2)
29561 delete arg2;
29562 }
29563 return NULL;
29564 }
29565
29566
29567 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29568 PyObject *resultobj;
29569 wxWindow *arg1 = (wxWindow *) 0 ;
29570 wxString *arg2 = 0 ;
29571 int *arg3 = (int *) 0 ;
29572 int *arg4 = (int *) 0 ;
29573 int *arg5 = (int *) 0 ;
29574 int *arg6 = (int *) 0 ;
29575 wxFont *arg7 = (wxFont *) NULL ;
29576 bool temp2 = false ;
29577 int temp3 ;
29578 int res3 = 0 ;
29579 int temp4 ;
29580 int res4 = 0 ;
29581 int temp5 ;
29582 int res5 = 0 ;
29583 int temp6 ;
29584 int res6 = 0 ;
29585 PyObject * obj0 = 0 ;
29586 PyObject * obj1 = 0 ;
29587 PyObject * obj2 = 0 ;
29588 char *kwnames[] = {
29589 (char *) "self",(char *) "string",(char *) "font", NULL
29590 };
29591
29592 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29593 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29594 arg5 = &temp5; res5 = SWIG_NEWOBJ;
29595 arg6 = &temp6; res6 = SWIG_NEWOBJ;
29596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
29597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29598 if (SWIG_arg_fail(1)) SWIG_fail;
29599 {
29600 arg2 = wxString_in_helper(obj1);
29601 if (arg2 == NULL) SWIG_fail;
29602 temp2 = true;
29603 }
29604 if (obj2) {
29605 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29606 if (SWIG_arg_fail(7)) SWIG_fail;
29607 }
29608 {
29609 PyThreadState* __tstate = wxPyBeginAllowThreads();
29610 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
29611
29612 wxPyEndAllowThreads(__tstate);
29613 if (PyErr_Occurred()) SWIG_fail;
29614 }
29615 Py_INCREF(Py_None); resultobj = Py_None;
29616 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29617 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29618 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29619 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29620 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
29621 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
29622 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
29623 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
29624 {
29625 if (temp2)
29626 delete arg2;
29627 }
29628 return resultobj;
29629 fail:
29630 {
29631 if (temp2)
29632 delete arg2;
29633 }
29634 return NULL;
29635 }
29636
29637
29638 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
29639 PyObject *resultobj;
29640 wxWindow *arg1 = (wxWindow *) 0 ;
29641 int *arg2 = (int *) 0 ;
29642 int *arg3 = (int *) 0 ;
29643 int temp2 ;
29644 int res2 = 0 ;
29645 int temp3 ;
29646 int res3 = 0 ;
29647 PyObject * obj0 = 0 ;
29648 PyObject * obj1 = 0 ;
29649 PyObject * obj2 = 0 ;
29650 char *kwnames[] = {
29651 (char *) "self",(char *) "x",(char *) "y", NULL
29652 };
29653
29654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29656 if (SWIG_arg_fail(1)) SWIG_fail;
29657 {
29658 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29659 temp2 = SWIG_As_int(obj1);
29660 if (SWIG_arg_fail(2)) SWIG_fail;
29661 arg2 = &temp2;
29662 res2 = SWIG_NEWOBJ;
29663 }
29664 }
29665 {
29666 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29667 temp3 = SWIG_As_int(obj2);
29668 if (SWIG_arg_fail(3)) SWIG_fail;
29669 arg3 = &temp3;
29670 res3 = SWIG_NEWOBJ;
29671 }
29672 }
29673 {
29674 PyThreadState* __tstate = wxPyBeginAllowThreads();
29675 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
29676
29677 wxPyEndAllowThreads(__tstate);
29678 if (PyErr_Occurred()) SWIG_fail;
29679 }
29680 Py_INCREF(Py_None); resultobj = Py_None;
29681 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29682 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29683 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29684 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29685 return resultobj;
29686 fail:
29687 return NULL;
29688 }
29689
29690
29691 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
29692 PyObject *resultobj;
29693 wxWindow *arg1 = (wxWindow *) 0 ;
29694 int *arg2 = (int *) 0 ;
29695 int *arg3 = (int *) 0 ;
29696 int temp2 ;
29697 int res2 = 0 ;
29698 int temp3 ;
29699 int res3 = 0 ;
29700 PyObject * obj0 = 0 ;
29701 PyObject * obj1 = 0 ;
29702 PyObject * obj2 = 0 ;
29703 char *kwnames[] = {
29704 (char *) "self",(char *) "x",(char *) "y", NULL
29705 };
29706
29707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29709 if (SWIG_arg_fail(1)) SWIG_fail;
29710 {
29711 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29712 temp2 = SWIG_As_int(obj1);
29713 if (SWIG_arg_fail(2)) SWIG_fail;
29714 arg2 = &temp2;
29715 res2 = SWIG_NEWOBJ;
29716 }
29717 }
29718 {
29719 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29720 temp3 = SWIG_As_int(obj2);
29721 if (SWIG_arg_fail(3)) SWIG_fail;
29722 arg3 = &temp3;
29723 res3 = SWIG_NEWOBJ;
29724 }
29725 }
29726 {
29727 PyThreadState* __tstate = wxPyBeginAllowThreads();
29728 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
29729
29730 wxPyEndAllowThreads(__tstate);
29731 if (PyErr_Occurred()) SWIG_fail;
29732 }
29733 Py_INCREF(Py_None); resultobj = Py_None;
29734 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29735 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29736 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29737 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29738 return resultobj;
29739 fail:
29740 return NULL;
29741 }
29742
29743
29744 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
29745 PyObject *resultobj;
29746 wxWindow *arg1 = (wxWindow *) 0 ;
29747 wxPoint *arg2 = 0 ;
29748 wxPoint result;
29749 wxPoint temp2 ;
29750 PyObject * obj0 = 0 ;
29751 PyObject * obj1 = 0 ;
29752 char *kwnames[] = {
29753 (char *) "self",(char *) "pt", NULL
29754 };
29755
29756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
29757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29758 if (SWIG_arg_fail(1)) SWIG_fail;
29759 {
29760 arg2 = &temp2;
29761 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29762 }
29763 {
29764 PyThreadState* __tstate = wxPyBeginAllowThreads();
29765 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
29766
29767 wxPyEndAllowThreads(__tstate);
29768 if (PyErr_Occurred()) SWIG_fail;
29769 }
29770 {
29771 wxPoint * resultptr;
29772 resultptr = new wxPoint((wxPoint &)(result));
29773 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29774 }
29775 return resultobj;
29776 fail:
29777 return NULL;
29778 }
29779
29780
29781 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
29782 PyObject *resultobj;
29783 wxWindow *arg1 = (wxWindow *) 0 ;
29784 wxPoint *arg2 = 0 ;
29785 wxPoint result;
29786 wxPoint temp2 ;
29787 PyObject * obj0 = 0 ;
29788 PyObject * obj1 = 0 ;
29789 char *kwnames[] = {
29790 (char *) "self",(char *) "pt", NULL
29791 };
29792
29793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
29794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29795 if (SWIG_arg_fail(1)) SWIG_fail;
29796 {
29797 arg2 = &temp2;
29798 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29799 }
29800 {
29801 PyThreadState* __tstate = wxPyBeginAllowThreads();
29802 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
29803
29804 wxPyEndAllowThreads(__tstate);
29805 if (PyErr_Occurred()) SWIG_fail;
29806 }
29807 {
29808 wxPoint * resultptr;
29809 resultptr = new wxPoint((wxPoint &)(result));
29810 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29811 }
29812 return resultobj;
29813 fail:
29814 return NULL;
29815 }
29816
29817
29818 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
29819 PyObject *resultobj;
29820 wxWindow *arg1 = (wxWindow *) 0 ;
29821 int arg2 ;
29822 int arg3 ;
29823 wxHitTest result;
29824 PyObject * obj0 = 0 ;
29825 PyObject * obj1 = 0 ;
29826 PyObject * obj2 = 0 ;
29827 char *kwnames[] = {
29828 (char *) "self",(char *) "x",(char *) "y", NULL
29829 };
29830
29831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29833 if (SWIG_arg_fail(1)) SWIG_fail;
29834 {
29835 arg2 = (int)(SWIG_As_int(obj1));
29836 if (SWIG_arg_fail(2)) SWIG_fail;
29837 }
29838 {
29839 arg3 = (int)(SWIG_As_int(obj2));
29840 if (SWIG_arg_fail(3)) SWIG_fail;
29841 }
29842 {
29843 PyThreadState* __tstate = wxPyBeginAllowThreads();
29844 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
29845
29846 wxPyEndAllowThreads(__tstate);
29847 if (PyErr_Occurred()) SWIG_fail;
29848 }
29849 resultobj = SWIG_From_int((result));
29850 return resultobj;
29851 fail:
29852 return NULL;
29853 }
29854
29855
29856 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
29857 PyObject *resultobj;
29858 wxWindow *arg1 = (wxWindow *) 0 ;
29859 wxPoint *arg2 = 0 ;
29860 wxHitTest result;
29861 wxPoint temp2 ;
29862 PyObject * obj0 = 0 ;
29863 PyObject * obj1 = 0 ;
29864 char *kwnames[] = {
29865 (char *) "self",(char *) "pt", NULL
29866 };
29867
29868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
29869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29870 if (SWIG_arg_fail(1)) SWIG_fail;
29871 {
29872 arg2 = &temp2;
29873 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29874 }
29875 {
29876 PyThreadState* __tstate = wxPyBeginAllowThreads();
29877 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
29878
29879 wxPyEndAllowThreads(__tstate);
29880 if (PyErr_Occurred()) SWIG_fail;
29881 }
29882 resultobj = SWIG_From_int((result));
29883 return resultobj;
29884 fail:
29885 return NULL;
29886 }
29887
29888
29889 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
29890 PyObject *resultobj;
29891 wxWindow *arg1 = (wxWindow *) 0 ;
29892 long arg2 ;
29893 wxBorder result;
29894 PyObject * obj0 = 0 ;
29895 PyObject * obj1 = 0 ;
29896
29897 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
29898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29899 if (SWIG_arg_fail(1)) SWIG_fail;
29900 {
29901 arg2 = (long)(SWIG_As_long(obj1));
29902 if (SWIG_arg_fail(2)) SWIG_fail;
29903 }
29904 {
29905 PyThreadState* __tstate = wxPyBeginAllowThreads();
29906 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
29907
29908 wxPyEndAllowThreads(__tstate);
29909 if (PyErr_Occurred()) SWIG_fail;
29910 }
29911 resultobj = SWIG_From_int((result));
29912 return resultobj;
29913 fail:
29914 return NULL;
29915 }
29916
29917
29918 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
29919 PyObject *resultobj;
29920 wxWindow *arg1 = (wxWindow *) 0 ;
29921 wxBorder result;
29922 PyObject * obj0 = 0 ;
29923
29924 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
29925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29926 if (SWIG_arg_fail(1)) SWIG_fail;
29927 {
29928 PyThreadState* __tstate = wxPyBeginAllowThreads();
29929 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
29930
29931 wxPyEndAllowThreads(__tstate);
29932 if (PyErr_Occurred()) SWIG_fail;
29933 }
29934 resultobj = SWIG_From_int((result));
29935 return resultobj;
29936 fail:
29937 return NULL;
29938 }
29939
29940
29941 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
29942 int argc;
29943 PyObject *argv[3];
29944 int ii;
29945
29946 argc = PyObject_Length(args);
29947 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
29948 argv[ii] = PyTuple_GetItem(args,ii);
29949 }
29950 if (argc == 1) {
29951 int _v;
29952 {
29953 void *ptr;
29954 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
29955 _v = 0;
29956 PyErr_Clear();
29957 } else {
29958 _v = 1;
29959 }
29960 }
29961 if (_v) {
29962 return _wrap_Window_GetBorder__SWIG_1(self,args);
29963 }
29964 }
29965 if (argc == 2) {
29966 int _v;
29967 {
29968 void *ptr;
29969 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
29970 _v = 0;
29971 PyErr_Clear();
29972 } else {
29973 _v = 1;
29974 }
29975 }
29976 if (_v) {
29977 _v = SWIG_Check_long(argv[1]);
29978 if (_v) {
29979 return _wrap_Window_GetBorder__SWIG_0(self,args);
29980 }
29981 }
29982 }
29983
29984 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
29985 return NULL;
29986 }
29987
29988
29989 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
29990 PyObject *resultobj;
29991 wxWindow *arg1 = (wxWindow *) 0 ;
29992 long arg2 = (long) wxUPDATE_UI_NONE ;
29993 PyObject * obj0 = 0 ;
29994 PyObject * obj1 = 0 ;
29995 char *kwnames[] = {
29996 (char *) "self",(char *) "flags", NULL
29997 };
29998
29999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30001 if (SWIG_arg_fail(1)) SWIG_fail;
30002 if (obj1) {
30003 {
30004 arg2 = (long)(SWIG_As_long(obj1));
30005 if (SWIG_arg_fail(2)) SWIG_fail;
30006 }
30007 }
30008 {
30009 PyThreadState* __tstate = wxPyBeginAllowThreads();
30010 (arg1)->UpdateWindowUI(arg2);
30011
30012 wxPyEndAllowThreads(__tstate);
30013 if (PyErr_Occurred()) SWIG_fail;
30014 }
30015 Py_INCREF(Py_None); resultobj = Py_None;
30016 return resultobj;
30017 fail:
30018 return NULL;
30019 }
30020
30021
30022 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30023 PyObject *resultobj;
30024 wxWindow *arg1 = (wxWindow *) 0 ;
30025 wxMenu *arg2 = (wxMenu *) 0 ;
30026 int arg3 = (int) -1 ;
30027 int arg4 = (int) -1 ;
30028 bool result;
30029 PyObject * obj0 = 0 ;
30030 PyObject * obj1 = 0 ;
30031 PyObject * obj2 = 0 ;
30032 PyObject * obj3 = 0 ;
30033 char *kwnames[] = {
30034 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30035 };
30036
30037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30039 if (SWIG_arg_fail(1)) SWIG_fail;
30040 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30041 if (SWIG_arg_fail(2)) SWIG_fail;
30042 if (obj2) {
30043 {
30044 arg3 = (int)(SWIG_As_int(obj2));
30045 if (SWIG_arg_fail(3)) SWIG_fail;
30046 }
30047 }
30048 if (obj3) {
30049 {
30050 arg4 = (int)(SWIG_As_int(obj3));
30051 if (SWIG_arg_fail(4)) SWIG_fail;
30052 }
30053 }
30054 {
30055 PyThreadState* __tstate = wxPyBeginAllowThreads();
30056 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30057
30058 wxPyEndAllowThreads(__tstate);
30059 if (PyErr_Occurred()) SWIG_fail;
30060 }
30061 {
30062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30063 }
30064 return resultobj;
30065 fail:
30066 return NULL;
30067 }
30068
30069
30070 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30071 PyObject *resultobj;
30072 wxWindow *arg1 = (wxWindow *) 0 ;
30073 wxMenu *arg2 = (wxMenu *) 0 ;
30074 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30075 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30076 bool result;
30077 wxPoint temp3 ;
30078 PyObject * obj0 = 0 ;
30079 PyObject * obj1 = 0 ;
30080 PyObject * obj2 = 0 ;
30081 char *kwnames[] = {
30082 (char *) "self",(char *) "menu",(char *) "pos", NULL
30083 };
30084
30085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30087 if (SWIG_arg_fail(1)) SWIG_fail;
30088 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30089 if (SWIG_arg_fail(2)) SWIG_fail;
30090 if (obj2) {
30091 {
30092 arg3 = &temp3;
30093 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30094 }
30095 }
30096 {
30097 PyThreadState* __tstate = wxPyBeginAllowThreads();
30098 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30099
30100 wxPyEndAllowThreads(__tstate);
30101 if (PyErr_Occurred()) SWIG_fail;
30102 }
30103 {
30104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30105 }
30106 return resultobj;
30107 fail:
30108 return NULL;
30109 }
30110
30111
30112 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30113 PyObject *resultobj;
30114 wxWindow *arg1 = (wxWindow *) 0 ;
30115 long result;
30116 PyObject * obj0 = 0 ;
30117 char *kwnames[] = {
30118 (char *) "self", NULL
30119 };
30120
30121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30123 if (SWIG_arg_fail(1)) SWIG_fail;
30124 {
30125 PyThreadState* __tstate = wxPyBeginAllowThreads();
30126 result = (long)wxWindow_GetHandle(arg1);
30127
30128 wxPyEndAllowThreads(__tstate);
30129 if (PyErr_Occurred()) SWIG_fail;
30130 }
30131 {
30132 resultobj = SWIG_From_long((long)(result));
30133 }
30134 return resultobj;
30135 fail:
30136 return NULL;
30137 }
30138
30139
30140 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30141 PyObject *resultobj;
30142 wxWindow *arg1 = (wxWindow *) 0 ;
30143 long arg2 ;
30144 PyObject * obj0 = 0 ;
30145 PyObject * obj1 = 0 ;
30146 char *kwnames[] = {
30147 (char *) "self",(char *) "handle", NULL
30148 };
30149
30150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30152 if (SWIG_arg_fail(1)) SWIG_fail;
30153 {
30154 arg2 = (long)(SWIG_As_long(obj1));
30155 if (SWIG_arg_fail(2)) SWIG_fail;
30156 }
30157 {
30158 PyThreadState* __tstate = wxPyBeginAllowThreads();
30159 wxWindow_AssociateHandle(arg1,arg2);
30160
30161 wxPyEndAllowThreads(__tstate);
30162 if (PyErr_Occurred()) SWIG_fail;
30163 }
30164 Py_INCREF(Py_None); resultobj = Py_None;
30165 return resultobj;
30166 fail:
30167 return NULL;
30168 }
30169
30170
30171 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30172 PyObject *resultobj;
30173 wxWindow *arg1 = (wxWindow *) 0 ;
30174 PyObject * obj0 = 0 ;
30175 char *kwnames[] = {
30176 (char *) "self", NULL
30177 };
30178
30179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30181 if (SWIG_arg_fail(1)) SWIG_fail;
30182 {
30183 PyThreadState* __tstate = wxPyBeginAllowThreads();
30184 (arg1)->DissociateHandle();
30185
30186 wxPyEndAllowThreads(__tstate);
30187 if (PyErr_Occurred()) SWIG_fail;
30188 }
30189 Py_INCREF(Py_None); resultobj = Py_None;
30190 return resultobj;
30191 fail:
30192 return NULL;
30193 }
30194
30195
30196 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30197 PyObject *resultobj;
30198 wxWindow *arg1 = (wxWindow *) 0 ;
30199 int arg2 ;
30200 bool result;
30201 PyObject * obj0 = 0 ;
30202 PyObject * obj1 = 0 ;
30203 char *kwnames[] = {
30204 (char *) "self",(char *) "orient", NULL
30205 };
30206
30207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30209 if (SWIG_arg_fail(1)) SWIG_fail;
30210 {
30211 arg2 = (int)(SWIG_As_int(obj1));
30212 if (SWIG_arg_fail(2)) SWIG_fail;
30213 }
30214 {
30215 PyThreadState* __tstate = wxPyBeginAllowThreads();
30216 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30217
30218 wxPyEndAllowThreads(__tstate);
30219 if (PyErr_Occurred()) SWIG_fail;
30220 }
30221 {
30222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30223 }
30224 return resultobj;
30225 fail:
30226 return NULL;
30227 }
30228
30229
30230 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30231 PyObject *resultobj;
30232 wxWindow *arg1 = (wxWindow *) 0 ;
30233 int arg2 ;
30234 int arg3 ;
30235 int arg4 ;
30236 int arg5 ;
30237 bool arg6 = (bool) true ;
30238 PyObject * obj0 = 0 ;
30239 PyObject * obj1 = 0 ;
30240 PyObject * obj2 = 0 ;
30241 PyObject * obj3 = 0 ;
30242 PyObject * obj4 = 0 ;
30243 PyObject * obj5 = 0 ;
30244 char *kwnames[] = {
30245 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30246 };
30247
30248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30250 if (SWIG_arg_fail(1)) SWIG_fail;
30251 {
30252 arg2 = (int)(SWIG_As_int(obj1));
30253 if (SWIG_arg_fail(2)) SWIG_fail;
30254 }
30255 {
30256 arg3 = (int)(SWIG_As_int(obj2));
30257 if (SWIG_arg_fail(3)) SWIG_fail;
30258 }
30259 {
30260 arg4 = (int)(SWIG_As_int(obj3));
30261 if (SWIG_arg_fail(4)) SWIG_fail;
30262 }
30263 {
30264 arg5 = (int)(SWIG_As_int(obj4));
30265 if (SWIG_arg_fail(5)) SWIG_fail;
30266 }
30267 if (obj5) {
30268 {
30269 arg6 = (bool)(SWIG_As_bool(obj5));
30270 if (SWIG_arg_fail(6)) SWIG_fail;
30271 }
30272 }
30273 {
30274 PyThreadState* __tstate = wxPyBeginAllowThreads();
30275 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30276
30277 wxPyEndAllowThreads(__tstate);
30278 if (PyErr_Occurred()) SWIG_fail;
30279 }
30280 Py_INCREF(Py_None); resultobj = Py_None;
30281 return resultobj;
30282 fail:
30283 return NULL;
30284 }
30285
30286
30287 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30288 PyObject *resultobj;
30289 wxWindow *arg1 = (wxWindow *) 0 ;
30290 int arg2 ;
30291 int arg3 ;
30292 bool arg4 = (bool) true ;
30293 PyObject * obj0 = 0 ;
30294 PyObject * obj1 = 0 ;
30295 PyObject * obj2 = 0 ;
30296 PyObject * obj3 = 0 ;
30297 char *kwnames[] = {
30298 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30299 };
30300
30301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30303 if (SWIG_arg_fail(1)) SWIG_fail;
30304 {
30305 arg2 = (int)(SWIG_As_int(obj1));
30306 if (SWIG_arg_fail(2)) SWIG_fail;
30307 }
30308 {
30309 arg3 = (int)(SWIG_As_int(obj2));
30310 if (SWIG_arg_fail(3)) SWIG_fail;
30311 }
30312 if (obj3) {
30313 {
30314 arg4 = (bool)(SWIG_As_bool(obj3));
30315 if (SWIG_arg_fail(4)) SWIG_fail;
30316 }
30317 }
30318 {
30319 PyThreadState* __tstate = wxPyBeginAllowThreads();
30320 (arg1)->SetScrollPos(arg2,arg3,arg4);
30321
30322 wxPyEndAllowThreads(__tstate);
30323 if (PyErr_Occurred()) SWIG_fail;
30324 }
30325 Py_INCREF(Py_None); resultobj = Py_None;
30326 return resultobj;
30327 fail:
30328 return NULL;
30329 }
30330
30331
30332 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30333 PyObject *resultobj;
30334 wxWindow *arg1 = (wxWindow *) 0 ;
30335 int arg2 ;
30336 int result;
30337 PyObject * obj0 = 0 ;
30338 PyObject * obj1 = 0 ;
30339 char *kwnames[] = {
30340 (char *) "self",(char *) "orientation", NULL
30341 };
30342
30343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30345 if (SWIG_arg_fail(1)) SWIG_fail;
30346 {
30347 arg2 = (int)(SWIG_As_int(obj1));
30348 if (SWIG_arg_fail(2)) SWIG_fail;
30349 }
30350 {
30351 PyThreadState* __tstate = wxPyBeginAllowThreads();
30352 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30353
30354 wxPyEndAllowThreads(__tstate);
30355 if (PyErr_Occurred()) SWIG_fail;
30356 }
30357 {
30358 resultobj = SWIG_From_int((int)(result));
30359 }
30360 return resultobj;
30361 fail:
30362 return NULL;
30363 }
30364
30365
30366 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30367 PyObject *resultobj;
30368 wxWindow *arg1 = (wxWindow *) 0 ;
30369 int arg2 ;
30370 int result;
30371 PyObject * obj0 = 0 ;
30372 PyObject * obj1 = 0 ;
30373 char *kwnames[] = {
30374 (char *) "self",(char *) "orientation", NULL
30375 };
30376
30377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30379 if (SWIG_arg_fail(1)) SWIG_fail;
30380 {
30381 arg2 = (int)(SWIG_As_int(obj1));
30382 if (SWIG_arg_fail(2)) SWIG_fail;
30383 }
30384 {
30385 PyThreadState* __tstate = wxPyBeginAllowThreads();
30386 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
30387
30388 wxPyEndAllowThreads(__tstate);
30389 if (PyErr_Occurred()) SWIG_fail;
30390 }
30391 {
30392 resultobj = SWIG_From_int((int)(result));
30393 }
30394 return resultobj;
30395 fail:
30396 return NULL;
30397 }
30398
30399
30400 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
30401 PyObject *resultobj;
30402 wxWindow *arg1 = (wxWindow *) 0 ;
30403 int arg2 ;
30404 int result;
30405 PyObject * obj0 = 0 ;
30406 PyObject * obj1 = 0 ;
30407 char *kwnames[] = {
30408 (char *) "self",(char *) "orientation", NULL
30409 };
30410
30411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
30412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30413 if (SWIG_arg_fail(1)) SWIG_fail;
30414 {
30415 arg2 = (int)(SWIG_As_int(obj1));
30416 if (SWIG_arg_fail(2)) SWIG_fail;
30417 }
30418 {
30419 PyThreadState* __tstate = wxPyBeginAllowThreads();
30420 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
30421
30422 wxPyEndAllowThreads(__tstate);
30423 if (PyErr_Occurred()) SWIG_fail;
30424 }
30425 {
30426 resultobj = SWIG_From_int((int)(result));
30427 }
30428 return resultobj;
30429 fail:
30430 return NULL;
30431 }
30432
30433
30434 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30435 PyObject *resultobj;
30436 wxWindow *arg1 = (wxWindow *) 0 ;
30437 int arg2 ;
30438 int arg3 ;
30439 wxRect *arg4 = (wxRect *) NULL ;
30440 PyObject * obj0 = 0 ;
30441 PyObject * obj1 = 0 ;
30442 PyObject * obj2 = 0 ;
30443 PyObject * obj3 = 0 ;
30444 char *kwnames[] = {
30445 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
30446 };
30447
30448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30450 if (SWIG_arg_fail(1)) SWIG_fail;
30451 {
30452 arg2 = (int)(SWIG_As_int(obj1));
30453 if (SWIG_arg_fail(2)) SWIG_fail;
30454 }
30455 {
30456 arg3 = (int)(SWIG_As_int(obj2));
30457 if (SWIG_arg_fail(3)) SWIG_fail;
30458 }
30459 if (obj3) {
30460 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30461 if (SWIG_arg_fail(4)) SWIG_fail;
30462 }
30463 {
30464 PyThreadState* __tstate = wxPyBeginAllowThreads();
30465 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
30466
30467 wxPyEndAllowThreads(__tstate);
30468 if (PyErr_Occurred()) SWIG_fail;
30469 }
30470 Py_INCREF(Py_None); resultobj = Py_None;
30471 return resultobj;
30472 fail:
30473 return NULL;
30474 }
30475
30476
30477 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
30478 PyObject *resultobj;
30479 wxWindow *arg1 = (wxWindow *) 0 ;
30480 int arg2 ;
30481 bool result;
30482 PyObject * obj0 = 0 ;
30483 PyObject * obj1 = 0 ;
30484 char *kwnames[] = {
30485 (char *) "self",(char *) "lines", NULL
30486 };
30487
30488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
30489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30490 if (SWIG_arg_fail(1)) SWIG_fail;
30491 {
30492 arg2 = (int)(SWIG_As_int(obj1));
30493 if (SWIG_arg_fail(2)) SWIG_fail;
30494 }
30495 {
30496 PyThreadState* __tstate = wxPyBeginAllowThreads();
30497 result = (bool)(arg1)->ScrollLines(arg2);
30498
30499 wxPyEndAllowThreads(__tstate);
30500 if (PyErr_Occurred()) SWIG_fail;
30501 }
30502 {
30503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30504 }
30505 return resultobj;
30506 fail:
30507 return NULL;
30508 }
30509
30510
30511 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
30512 PyObject *resultobj;
30513 wxWindow *arg1 = (wxWindow *) 0 ;
30514 int arg2 ;
30515 bool result;
30516 PyObject * obj0 = 0 ;
30517 PyObject * obj1 = 0 ;
30518 char *kwnames[] = {
30519 (char *) "self",(char *) "pages", NULL
30520 };
30521
30522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
30523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30524 if (SWIG_arg_fail(1)) SWIG_fail;
30525 {
30526 arg2 = (int)(SWIG_As_int(obj1));
30527 if (SWIG_arg_fail(2)) SWIG_fail;
30528 }
30529 {
30530 PyThreadState* __tstate = wxPyBeginAllowThreads();
30531 result = (bool)(arg1)->ScrollPages(arg2);
30532
30533 wxPyEndAllowThreads(__tstate);
30534 if (PyErr_Occurred()) SWIG_fail;
30535 }
30536 {
30537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30538 }
30539 return resultobj;
30540 fail:
30541 return NULL;
30542 }
30543
30544
30545 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
30546 PyObject *resultobj;
30547 wxWindow *arg1 = (wxWindow *) 0 ;
30548 bool result;
30549 PyObject * obj0 = 0 ;
30550 char *kwnames[] = {
30551 (char *) "self", NULL
30552 };
30553
30554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
30555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30556 if (SWIG_arg_fail(1)) SWIG_fail;
30557 {
30558 PyThreadState* __tstate = wxPyBeginAllowThreads();
30559 result = (bool)(arg1)->LineUp();
30560
30561 wxPyEndAllowThreads(__tstate);
30562 if (PyErr_Occurred()) SWIG_fail;
30563 }
30564 {
30565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30566 }
30567 return resultobj;
30568 fail:
30569 return NULL;
30570 }
30571
30572
30573 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
30574 PyObject *resultobj;
30575 wxWindow *arg1 = (wxWindow *) 0 ;
30576 bool result;
30577 PyObject * obj0 = 0 ;
30578 char *kwnames[] = {
30579 (char *) "self", NULL
30580 };
30581
30582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
30583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30584 if (SWIG_arg_fail(1)) SWIG_fail;
30585 {
30586 PyThreadState* __tstate = wxPyBeginAllowThreads();
30587 result = (bool)(arg1)->LineDown();
30588
30589 wxPyEndAllowThreads(__tstate);
30590 if (PyErr_Occurred()) SWIG_fail;
30591 }
30592 {
30593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30594 }
30595 return resultobj;
30596 fail:
30597 return NULL;
30598 }
30599
30600
30601 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
30602 PyObject *resultobj;
30603 wxWindow *arg1 = (wxWindow *) 0 ;
30604 bool result;
30605 PyObject * obj0 = 0 ;
30606 char *kwnames[] = {
30607 (char *) "self", NULL
30608 };
30609
30610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
30611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30612 if (SWIG_arg_fail(1)) SWIG_fail;
30613 {
30614 PyThreadState* __tstate = wxPyBeginAllowThreads();
30615 result = (bool)(arg1)->PageUp();
30616
30617 wxPyEndAllowThreads(__tstate);
30618 if (PyErr_Occurred()) SWIG_fail;
30619 }
30620 {
30621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30622 }
30623 return resultobj;
30624 fail:
30625 return NULL;
30626 }
30627
30628
30629 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
30630 PyObject *resultobj;
30631 wxWindow *arg1 = (wxWindow *) 0 ;
30632 bool result;
30633 PyObject * obj0 = 0 ;
30634 char *kwnames[] = {
30635 (char *) "self", NULL
30636 };
30637
30638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
30639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30640 if (SWIG_arg_fail(1)) SWIG_fail;
30641 {
30642 PyThreadState* __tstate = wxPyBeginAllowThreads();
30643 result = (bool)(arg1)->PageDown();
30644
30645 wxPyEndAllowThreads(__tstate);
30646 if (PyErr_Occurred()) SWIG_fail;
30647 }
30648 {
30649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30650 }
30651 return resultobj;
30652 fail:
30653 return NULL;
30654 }
30655
30656
30657 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30658 PyObject *resultobj;
30659 wxWindow *arg1 = (wxWindow *) 0 ;
30660 wxString *arg2 = 0 ;
30661 bool temp2 = false ;
30662 PyObject * obj0 = 0 ;
30663 PyObject * obj1 = 0 ;
30664 char *kwnames[] = {
30665 (char *) "self",(char *) "text", NULL
30666 };
30667
30668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
30669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30670 if (SWIG_arg_fail(1)) SWIG_fail;
30671 {
30672 arg2 = wxString_in_helper(obj1);
30673 if (arg2 == NULL) SWIG_fail;
30674 temp2 = true;
30675 }
30676 {
30677 PyThreadState* __tstate = wxPyBeginAllowThreads();
30678 (arg1)->SetHelpText((wxString const &)*arg2);
30679
30680 wxPyEndAllowThreads(__tstate);
30681 if (PyErr_Occurred()) SWIG_fail;
30682 }
30683 Py_INCREF(Py_None); resultobj = Py_None;
30684 {
30685 if (temp2)
30686 delete arg2;
30687 }
30688 return resultobj;
30689 fail:
30690 {
30691 if (temp2)
30692 delete arg2;
30693 }
30694 return NULL;
30695 }
30696
30697
30698 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
30699 PyObject *resultobj;
30700 wxWindow *arg1 = (wxWindow *) 0 ;
30701 wxString *arg2 = 0 ;
30702 bool temp2 = false ;
30703 PyObject * obj0 = 0 ;
30704 PyObject * obj1 = 0 ;
30705 char *kwnames[] = {
30706 (char *) "self",(char *) "text", NULL
30707 };
30708
30709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
30710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30711 if (SWIG_arg_fail(1)) SWIG_fail;
30712 {
30713 arg2 = wxString_in_helper(obj1);
30714 if (arg2 == NULL) SWIG_fail;
30715 temp2 = true;
30716 }
30717 {
30718 PyThreadState* __tstate = wxPyBeginAllowThreads();
30719 (arg1)->SetHelpTextForId((wxString const &)*arg2);
30720
30721 wxPyEndAllowThreads(__tstate);
30722 if (PyErr_Occurred()) SWIG_fail;
30723 }
30724 Py_INCREF(Py_None); resultobj = Py_None;
30725 {
30726 if (temp2)
30727 delete arg2;
30728 }
30729 return resultobj;
30730 fail:
30731 {
30732 if (temp2)
30733 delete arg2;
30734 }
30735 return NULL;
30736 }
30737
30738
30739 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30740 PyObject *resultobj;
30741 wxWindow *arg1 = (wxWindow *) 0 ;
30742 wxString result;
30743 PyObject * obj0 = 0 ;
30744 char *kwnames[] = {
30745 (char *) "self", NULL
30746 };
30747
30748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
30749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30750 if (SWIG_arg_fail(1)) SWIG_fail;
30751 {
30752 PyThreadState* __tstate = wxPyBeginAllowThreads();
30753 result = ((wxWindow const *)arg1)->GetHelpText();
30754
30755 wxPyEndAllowThreads(__tstate);
30756 if (PyErr_Occurred()) SWIG_fail;
30757 }
30758 {
30759 #if wxUSE_UNICODE
30760 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30761 #else
30762 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30763 #endif
30764 }
30765 return resultobj;
30766 fail:
30767 return NULL;
30768 }
30769
30770
30771 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
30772 PyObject *resultobj;
30773 wxWindow *arg1 = (wxWindow *) 0 ;
30774 wxString *arg2 = 0 ;
30775 bool temp2 = false ;
30776 PyObject * obj0 = 0 ;
30777 PyObject * obj1 = 0 ;
30778 char *kwnames[] = {
30779 (char *) "self",(char *) "tip", NULL
30780 };
30781
30782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
30783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30784 if (SWIG_arg_fail(1)) SWIG_fail;
30785 {
30786 arg2 = wxString_in_helper(obj1);
30787 if (arg2 == NULL) SWIG_fail;
30788 temp2 = true;
30789 }
30790 {
30791 PyThreadState* __tstate = wxPyBeginAllowThreads();
30792 (arg1)->SetToolTip((wxString const &)*arg2);
30793
30794 wxPyEndAllowThreads(__tstate);
30795 if (PyErr_Occurred()) SWIG_fail;
30796 }
30797 Py_INCREF(Py_None); resultobj = Py_None;
30798 {
30799 if (temp2)
30800 delete arg2;
30801 }
30802 return resultobj;
30803 fail:
30804 {
30805 if (temp2)
30806 delete arg2;
30807 }
30808 return NULL;
30809 }
30810
30811
30812 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
30813 PyObject *resultobj;
30814 wxWindow *arg1 = (wxWindow *) 0 ;
30815 wxToolTip *arg2 = (wxToolTip *) 0 ;
30816 PyObject * obj0 = 0 ;
30817 PyObject * obj1 = 0 ;
30818 char *kwnames[] = {
30819 (char *) "self",(char *) "tip", NULL
30820 };
30821
30822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
30823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30824 if (SWIG_arg_fail(1)) SWIG_fail;
30825 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
30826 if (SWIG_arg_fail(2)) SWIG_fail;
30827 {
30828 PyThreadState* __tstate = wxPyBeginAllowThreads();
30829 (arg1)->SetToolTip(arg2);
30830
30831 wxPyEndAllowThreads(__tstate);
30832 if (PyErr_Occurred()) SWIG_fail;
30833 }
30834 Py_INCREF(Py_None); resultobj = Py_None;
30835 return resultobj;
30836 fail:
30837 return NULL;
30838 }
30839
30840
30841 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
30842 PyObject *resultobj;
30843 wxWindow *arg1 = (wxWindow *) 0 ;
30844 wxToolTip *result;
30845 PyObject * obj0 = 0 ;
30846 char *kwnames[] = {
30847 (char *) "self", NULL
30848 };
30849
30850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
30851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30852 if (SWIG_arg_fail(1)) SWIG_fail;
30853 {
30854 PyThreadState* __tstate = wxPyBeginAllowThreads();
30855 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
30856
30857 wxPyEndAllowThreads(__tstate);
30858 if (PyErr_Occurred()) SWIG_fail;
30859 }
30860 {
30861 resultobj = wxPyMake_wxObject(result, 0);
30862 }
30863 return resultobj;
30864 fail:
30865 return NULL;
30866 }
30867
30868
30869 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30870 PyObject *resultobj;
30871 wxWindow *arg1 = (wxWindow *) 0 ;
30872 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
30873 PyObject * obj0 = 0 ;
30874 PyObject * obj1 = 0 ;
30875 char *kwnames[] = {
30876 (char *) "self",(char *) "dropTarget", NULL
30877 };
30878
30879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
30880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30881 if (SWIG_arg_fail(1)) SWIG_fail;
30882 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30883 if (SWIG_arg_fail(2)) SWIG_fail;
30884 {
30885 PyThreadState* __tstate = wxPyBeginAllowThreads();
30886 (arg1)->SetDropTarget(arg2);
30887
30888 wxPyEndAllowThreads(__tstate);
30889 if (PyErr_Occurred()) SWIG_fail;
30890 }
30891 Py_INCREF(Py_None); resultobj = Py_None;
30892 return resultobj;
30893 fail:
30894 return NULL;
30895 }
30896
30897
30898 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30899 PyObject *resultobj;
30900 wxWindow *arg1 = (wxWindow *) 0 ;
30901 wxPyDropTarget *result;
30902 PyObject * obj0 = 0 ;
30903 char *kwnames[] = {
30904 (char *) "self", NULL
30905 };
30906
30907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
30908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30909 if (SWIG_arg_fail(1)) SWIG_fail;
30910 {
30911 PyThreadState* __tstate = wxPyBeginAllowThreads();
30912 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
30913
30914 wxPyEndAllowThreads(__tstate);
30915 if (PyErr_Occurred()) SWIG_fail;
30916 }
30917 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
30918 return resultobj;
30919 fail:
30920 return NULL;
30921 }
30922
30923
30924 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
30925 PyObject *resultobj;
30926 wxWindow *arg1 = (wxWindow *) 0 ;
30927 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
30928 PyObject * obj0 = 0 ;
30929 PyObject * obj1 = 0 ;
30930 char *kwnames[] = {
30931 (char *) "self",(char *) "constraints", NULL
30932 };
30933
30934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
30935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30936 if (SWIG_arg_fail(1)) SWIG_fail;
30937 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
30938 if (SWIG_arg_fail(2)) SWIG_fail;
30939 {
30940 PyThreadState* __tstate = wxPyBeginAllowThreads();
30941 (arg1)->SetConstraints(arg2);
30942
30943 wxPyEndAllowThreads(__tstate);
30944 if (PyErr_Occurred()) SWIG_fail;
30945 }
30946 Py_INCREF(Py_None); resultobj = Py_None;
30947 return resultobj;
30948 fail:
30949 return NULL;
30950 }
30951
30952
30953 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
30954 PyObject *resultobj;
30955 wxWindow *arg1 = (wxWindow *) 0 ;
30956 wxLayoutConstraints *result;
30957 PyObject * obj0 = 0 ;
30958 char *kwnames[] = {
30959 (char *) "self", NULL
30960 };
30961
30962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
30963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30964 if (SWIG_arg_fail(1)) SWIG_fail;
30965 {
30966 PyThreadState* __tstate = wxPyBeginAllowThreads();
30967 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
30968
30969 wxPyEndAllowThreads(__tstate);
30970 if (PyErr_Occurred()) SWIG_fail;
30971 }
30972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
30973 return resultobj;
30974 fail:
30975 return NULL;
30976 }
30977
30978
30979 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
30980 PyObject *resultobj;
30981 wxWindow *arg1 = (wxWindow *) 0 ;
30982 bool arg2 ;
30983 PyObject * obj0 = 0 ;
30984 PyObject * obj1 = 0 ;
30985 char *kwnames[] = {
30986 (char *) "self",(char *) "autoLayout", NULL
30987 };
30988
30989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
30990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30991 if (SWIG_arg_fail(1)) SWIG_fail;
30992 {
30993 arg2 = (bool)(SWIG_As_bool(obj1));
30994 if (SWIG_arg_fail(2)) SWIG_fail;
30995 }
30996 {
30997 PyThreadState* __tstate = wxPyBeginAllowThreads();
30998 (arg1)->SetAutoLayout(arg2);
30999
31000 wxPyEndAllowThreads(__tstate);
31001 if (PyErr_Occurred()) SWIG_fail;
31002 }
31003 Py_INCREF(Py_None); resultobj = Py_None;
31004 return resultobj;
31005 fail:
31006 return NULL;
31007 }
31008
31009
31010 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31011 PyObject *resultobj;
31012 wxWindow *arg1 = (wxWindow *) 0 ;
31013 bool result;
31014 PyObject * obj0 = 0 ;
31015 char *kwnames[] = {
31016 (char *) "self", NULL
31017 };
31018
31019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31021 if (SWIG_arg_fail(1)) SWIG_fail;
31022 {
31023 PyThreadState* __tstate = wxPyBeginAllowThreads();
31024 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31025
31026 wxPyEndAllowThreads(__tstate);
31027 if (PyErr_Occurred()) SWIG_fail;
31028 }
31029 {
31030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31031 }
31032 return resultobj;
31033 fail:
31034 return NULL;
31035 }
31036
31037
31038 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31039 PyObject *resultobj;
31040 wxWindow *arg1 = (wxWindow *) 0 ;
31041 bool result;
31042 PyObject * obj0 = 0 ;
31043 char *kwnames[] = {
31044 (char *) "self", NULL
31045 };
31046
31047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31049 if (SWIG_arg_fail(1)) SWIG_fail;
31050 {
31051 PyThreadState* __tstate = wxPyBeginAllowThreads();
31052 result = (bool)(arg1)->Layout();
31053
31054 wxPyEndAllowThreads(__tstate);
31055 if (PyErr_Occurred()) SWIG_fail;
31056 }
31057 {
31058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31059 }
31060 return resultobj;
31061 fail:
31062 return NULL;
31063 }
31064
31065
31066 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31067 PyObject *resultobj;
31068 wxWindow *arg1 = (wxWindow *) 0 ;
31069 wxSizer *arg2 = (wxSizer *) 0 ;
31070 bool arg3 = (bool) true ;
31071 PyObject * obj0 = 0 ;
31072 PyObject * obj1 = 0 ;
31073 PyObject * obj2 = 0 ;
31074 char *kwnames[] = {
31075 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31076 };
31077
31078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31080 if (SWIG_arg_fail(1)) SWIG_fail;
31081 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31082 if (SWIG_arg_fail(2)) SWIG_fail;
31083 if (obj2) {
31084 {
31085 arg3 = (bool)(SWIG_As_bool(obj2));
31086 if (SWIG_arg_fail(3)) SWIG_fail;
31087 }
31088 }
31089 {
31090 PyThreadState* __tstate = wxPyBeginAllowThreads();
31091 (arg1)->SetSizer(arg2,arg3);
31092
31093 wxPyEndAllowThreads(__tstate);
31094 if (PyErr_Occurred()) SWIG_fail;
31095 }
31096 Py_INCREF(Py_None); resultobj = Py_None;
31097 return resultobj;
31098 fail:
31099 return NULL;
31100 }
31101
31102
31103 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31104 PyObject *resultobj;
31105 wxWindow *arg1 = (wxWindow *) 0 ;
31106 wxSizer *arg2 = (wxSizer *) 0 ;
31107 bool arg3 = (bool) true ;
31108 PyObject * obj0 = 0 ;
31109 PyObject * obj1 = 0 ;
31110 PyObject * obj2 = 0 ;
31111 char *kwnames[] = {
31112 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31113 };
31114
31115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31117 if (SWIG_arg_fail(1)) SWIG_fail;
31118 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31119 if (SWIG_arg_fail(2)) SWIG_fail;
31120 if (obj2) {
31121 {
31122 arg3 = (bool)(SWIG_As_bool(obj2));
31123 if (SWIG_arg_fail(3)) SWIG_fail;
31124 }
31125 }
31126 {
31127 PyThreadState* __tstate = wxPyBeginAllowThreads();
31128 (arg1)->SetSizerAndFit(arg2,arg3);
31129
31130 wxPyEndAllowThreads(__tstate);
31131 if (PyErr_Occurred()) SWIG_fail;
31132 }
31133 Py_INCREF(Py_None); resultobj = Py_None;
31134 return resultobj;
31135 fail:
31136 return NULL;
31137 }
31138
31139
31140 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31141 PyObject *resultobj;
31142 wxWindow *arg1 = (wxWindow *) 0 ;
31143 wxSizer *result;
31144 PyObject * obj0 = 0 ;
31145 char *kwnames[] = {
31146 (char *) "self", NULL
31147 };
31148
31149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31151 if (SWIG_arg_fail(1)) SWIG_fail;
31152 {
31153 PyThreadState* __tstate = wxPyBeginAllowThreads();
31154 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31155
31156 wxPyEndAllowThreads(__tstate);
31157 if (PyErr_Occurred()) SWIG_fail;
31158 }
31159 {
31160 resultobj = wxPyMake_wxSizer(result, 0);
31161 }
31162 return resultobj;
31163 fail:
31164 return NULL;
31165 }
31166
31167
31168 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31169 PyObject *resultobj;
31170 wxWindow *arg1 = (wxWindow *) 0 ;
31171 wxSizer *arg2 = (wxSizer *) 0 ;
31172 PyObject * obj0 = 0 ;
31173 PyObject * obj1 = 0 ;
31174 char *kwnames[] = {
31175 (char *) "self",(char *) "sizer", NULL
31176 };
31177
31178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31180 if (SWIG_arg_fail(1)) SWIG_fail;
31181 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31182 if (SWIG_arg_fail(2)) SWIG_fail;
31183 {
31184 PyThreadState* __tstate = wxPyBeginAllowThreads();
31185 (arg1)->SetContainingSizer(arg2);
31186
31187 wxPyEndAllowThreads(__tstate);
31188 if (PyErr_Occurred()) SWIG_fail;
31189 }
31190 Py_INCREF(Py_None); resultobj = Py_None;
31191 return resultobj;
31192 fail:
31193 return NULL;
31194 }
31195
31196
31197 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31198 PyObject *resultobj;
31199 wxWindow *arg1 = (wxWindow *) 0 ;
31200 wxSizer *result;
31201 PyObject * obj0 = 0 ;
31202 char *kwnames[] = {
31203 (char *) "self", NULL
31204 };
31205
31206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31208 if (SWIG_arg_fail(1)) SWIG_fail;
31209 {
31210 PyThreadState* __tstate = wxPyBeginAllowThreads();
31211 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31212
31213 wxPyEndAllowThreads(__tstate);
31214 if (PyErr_Occurred()) SWIG_fail;
31215 }
31216 {
31217 resultobj = wxPyMake_wxSizer(result, 0);
31218 }
31219 return resultobj;
31220 fail:
31221 return NULL;
31222 }
31223
31224
31225 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31226 PyObject *resultobj;
31227 wxWindow *arg1 = (wxWindow *) 0 ;
31228 PyObject * obj0 = 0 ;
31229 char *kwnames[] = {
31230 (char *) "self", NULL
31231 };
31232
31233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31235 if (SWIG_arg_fail(1)) SWIG_fail;
31236 {
31237 PyThreadState* __tstate = wxPyBeginAllowThreads();
31238 (arg1)->InheritAttributes();
31239
31240 wxPyEndAllowThreads(__tstate);
31241 if (PyErr_Occurred()) SWIG_fail;
31242 }
31243 Py_INCREF(Py_None); resultobj = Py_None;
31244 return resultobj;
31245 fail:
31246 return NULL;
31247 }
31248
31249
31250 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31251 PyObject *resultobj;
31252 wxWindow *arg1 = (wxWindow *) 0 ;
31253 bool result;
31254 PyObject * obj0 = 0 ;
31255 char *kwnames[] = {
31256 (char *) "self", NULL
31257 };
31258
31259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31261 if (SWIG_arg_fail(1)) SWIG_fail;
31262 {
31263 PyThreadState* __tstate = wxPyBeginAllowThreads();
31264 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31265
31266 wxPyEndAllowThreads(__tstate);
31267 if (PyErr_Occurred()) SWIG_fail;
31268 }
31269 {
31270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31271 }
31272 return resultobj;
31273 fail:
31274 return NULL;
31275 }
31276
31277
31278 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31279 PyObject *obj;
31280 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31281 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31282 Py_INCREF(obj);
31283 return Py_BuildValue((char *)"");
31284 }
31285 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31286 PyObject *resultobj;
31287 long arg1 ;
31288 wxWindow *arg2 = (wxWindow *) NULL ;
31289 wxWindow *result;
31290 PyObject * obj0 = 0 ;
31291 PyObject * obj1 = 0 ;
31292 char *kwnames[] = {
31293 (char *) "id",(char *) "parent", NULL
31294 };
31295
31296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31297 {
31298 arg1 = (long)(SWIG_As_long(obj0));
31299 if (SWIG_arg_fail(1)) SWIG_fail;
31300 }
31301 if (obj1) {
31302 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31303 if (SWIG_arg_fail(2)) SWIG_fail;
31304 }
31305 {
31306 if (!wxPyCheckForApp()) SWIG_fail;
31307 PyThreadState* __tstate = wxPyBeginAllowThreads();
31308 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31309
31310 wxPyEndAllowThreads(__tstate);
31311 if (PyErr_Occurred()) SWIG_fail;
31312 }
31313 {
31314 resultobj = wxPyMake_wxObject(result, 0);
31315 }
31316 return resultobj;
31317 fail:
31318 return NULL;
31319 }
31320
31321
31322 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31323 PyObject *resultobj;
31324 wxString *arg1 = 0 ;
31325 wxWindow *arg2 = (wxWindow *) NULL ;
31326 wxWindow *result;
31327 bool temp1 = false ;
31328 PyObject * obj0 = 0 ;
31329 PyObject * obj1 = 0 ;
31330 char *kwnames[] = {
31331 (char *) "name",(char *) "parent", NULL
31332 };
31333
31334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31335 {
31336 arg1 = wxString_in_helper(obj0);
31337 if (arg1 == NULL) SWIG_fail;
31338 temp1 = true;
31339 }
31340 if (obj1) {
31341 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31342 if (SWIG_arg_fail(2)) SWIG_fail;
31343 }
31344 {
31345 if (!wxPyCheckForApp()) SWIG_fail;
31346 PyThreadState* __tstate = wxPyBeginAllowThreads();
31347 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31348
31349 wxPyEndAllowThreads(__tstate);
31350 if (PyErr_Occurred()) SWIG_fail;
31351 }
31352 {
31353 resultobj = wxPyMake_wxObject(result, 0);
31354 }
31355 {
31356 if (temp1)
31357 delete arg1;
31358 }
31359 return resultobj;
31360 fail:
31361 {
31362 if (temp1)
31363 delete arg1;
31364 }
31365 return NULL;
31366 }
31367
31368
31369 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
31370 PyObject *resultobj;
31371 wxString *arg1 = 0 ;
31372 wxWindow *arg2 = (wxWindow *) NULL ;
31373 wxWindow *result;
31374 bool temp1 = false ;
31375 PyObject * obj0 = 0 ;
31376 PyObject * obj1 = 0 ;
31377 char *kwnames[] = {
31378 (char *) "label",(char *) "parent", NULL
31379 };
31380
31381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
31382 {
31383 arg1 = wxString_in_helper(obj0);
31384 if (arg1 == NULL) SWIG_fail;
31385 temp1 = true;
31386 }
31387 if (obj1) {
31388 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31389 if (SWIG_arg_fail(2)) SWIG_fail;
31390 }
31391 {
31392 if (!wxPyCheckForApp()) SWIG_fail;
31393 PyThreadState* __tstate = wxPyBeginAllowThreads();
31394 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
31395
31396 wxPyEndAllowThreads(__tstate);
31397 if (PyErr_Occurred()) SWIG_fail;
31398 }
31399 {
31400 resultobj = wxPyMake_wxObject(result, 0);
31401 }
31402 {
31403 if (temp1)
31404 delete arg1;
31405 }
31406 return resultobj;
31407 fail:
31408 {
31409 if (temp1)
31410 delete arg1;
31411 }
31412 return NULL;
31413 }
31414
31415
31416 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
31417 PyObject *resultobj;
31418 wxWindow *arg1 = (wxWindow *) 0 ;
31419 unsigned long arg2 ;
31420 wxWindow *result;
31421 PyObject * obj0 = 0 ;
31422 PyObject * obj1 = 0 ;
31423 char *kwnames[] = {
31424 (char *) "parent",(char *) "_hWnd", NULL
31425 };
31426
31427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
31428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31429 if (SWIG_arg_fail(1)) SWIG_fail;
31430 {
31431 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
31432 if (SWIG_arg_fail(2)) SWIG_fail;
31433 }
31434 {
31435 PyThreadState* __tstate = wxPyBeginAllowThreads();
31436 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
31437
31438 wxPyEndAllowThreads(__tstate);
31439 if (PyErr_Occurred()) SWIG_fail;
31440 }
31441 {
31442 resultobj = wxPyMake_wxObject(result, 0);
31443 }
31444 return resultobj;
31445 fail:
31446 return NULL;
31447 }
31448
31449
31450 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
31451 PyObject *resultobj;
31452 wxValidator *result;
31453 char *kwnames[] = {
31454 NULL
31455 };
31456
31457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
31458 {
31459 PyThreadState* __tstate = wxPyBeginAllowThreads();
31460 result = (wxValidator *)new wxValidator();
31461
31462 wxPyEndAllowThreads(__tstate);
31463 if (PyErr_Occurred()) SWIG_fail;
31464 }
31465 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
31466 return resultobj;
31467 fail:
31468 return NULL;
31469 }
31470
31471
31472 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
31473 PyObject *resultobj;
31474 wxValidator *arg1 = (wxValidator *) 0 ;
31475 wxValidator *result;
31476 PyObject * obj0 = 0 ;
31477 char *kwnames[] = {
31478 (char *) "self", NULL
31479 };
31480
31481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
31482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31483 if (SWIG_arg_fail(1)) SWIG_fail;
31484 {
31485 PyThreadState* __tstate = wxPyBeginAllowThreads();
31486 result = (wxValidator *)(arg1)->Clone();
31487
31488 wxPyEndAllowThreads(__tstate);
31489 if (PyErr_Occurred()) SWIG_fail;
31490 }
31491 {
31492 resultobj = wxPyMake_wxObject(result, 0);
31493 }
31494 return resultobj;
31495 fail:
31496 return NULL;
31497 }
31498
31499
31500 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
31501 PyObject *resultobj;
31502 wxValidator *arg1 = (wxValidator *) 0 ;
31503 wxWindow *arg2 = (wxWindow *) 0 ;
31504 bool result;
31505 PyObject * obj0 = 0 ;
31506 PyObject * obj1 = 0 ;
31507 char *kwnames[] = {
31508 (char *) "self",(char *) "parent", NULL
31509 };
31510
31511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
31512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31513 if (SWIG_arg_fail(1)) SWIG_fail;
31514 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31515 if (SWIG_arg_fail(2)) SWIG_fail;
31516 {
31517 PyThreadState* __tstate = wxPyBeginAllowThreads();
31518 result = (bool)(arg1)->Validate(arg2);
31519
31520 wxPyEndAllowThreads(__tstate);
31521 if (PyErr_Occurred()) SWIG_fail;
31522 }
31523 {
31524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31525 }
31526 return resultobj;
31527 fail:
31528 return NULL;
31529 }
31530
31531
31532 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31533 PyObject *resultobj;
31534 wxValidator *arg1 = (wxValidator *) 0 ;
31535 bool result;
31536 PyObject * obj0 = 0 ;
31537 char *kwnames[] = {
31538 (char *) "self", NULL
31539 };
31540
31541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
31542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31543 if (SWIG_arg_fail(1)) SWIG_fail;
31544 {
31545 PyThreadState* __tstate = wxPyBeginAllowThreads();
31546 result = (bool)(arg1)->TransferToWindow();
31547
31548 wxPyEndAllowThreads(__tstate);
31549 if (PyErr_Occurred()) SWIG_fail;
31550 }
31551 {
31552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31553 }
31554 return resultobj;
31555 fail:
31556 return NULL;
31557 }
31558
31559
31560 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31561 PyObject *resultobj;
31562 wxValidator *arg1 = (wxValidator *) 0 ;
31563 bool result;
31564 PyObject * obj0 = 0 ;
31565 char *kwnames[] = {
31566 (char *) "self", NULL
31567 };
31568
31569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
31570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31571 if (SWIG_arg_fail(1)) SWIG_fail;
31572 {
31573 PyThreadState* __tstate = wxPyBeginAllowThreads();
31574 result = (bool)(arg1)->TransferFromWindow();
31575
31576 wxPyEndAllowThreads(__tstate);
31577 if (PyErr_Occurred()) SWIG_fail;
31578 }
31579 {
31580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31581 }
31582 return resultobj;
31583 fail:
31584 return NULL;
31585 }
31586
31587
31588 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31589 PyObject *resultobj;
31590 wxValidator *arg1 = (wxValidator *) 0 ;
31591 wxWindow *result;
31592 PyObject * obj0 = 0 ;
31593 char *kwnames[] = {
31594 (char *) "self", NULL
31595 };
31596
31597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
31598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31599 if (SWIG_arg_fail(1)) SWIG_fail;
31600 {
31601 PyThreadState* __tstate = wxPyBeginAllowThreads();
31602 result = (wxWindow *)(arg1)->GetWindow();
31603
31604 wxPyEndAllowThreads(__tstate);
31605 if (PyErr_Occurred()) SWIG_fail;
31606 }
31607 {
31608 resultobj = wxPyMake_wxObject(result, 0);
31609 }
31610 return resultobj;
31611 fail:
31612 return NULL;
31613 }
31614
31615
31616 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31617 PyObject *resultobj;
31618 wxValidator *arg1 = (wxValidator *) 0 ;
31619 wxWindow *arg2 = (wxWindow *) 0 ;
31620 PyObject * obj0 = 0 ;
31621 PyObject * obj1 = 0 ;
31622 char *kwnames[] = {
31623 (char *) "self",(char *) "window", NULL
31624 };
31625
31626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
31627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31628 if (SWIG_arg_fail(1)) SWIG_fail;
31629 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31630 if (SWIG_arg_fail(2)) SWIG_fail;
31631 {
31632 PyThreadState* __tstate = wxPyBeginAllowThreads();
31633 (arg1)->SetWindow(arg2);
31634
31635 wxPyEndAllowThreads(__tstate);
31636 if (PyErr_Occurred()) SWIG_fail;
31637 }
31638 Py_INCREF(Py_None); resultobj = Py_None;
31639 return resultobj;
31640 fail:
31641 return NULL;
31642 }
31643
31644
31645 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
31646 PyObject *resultobj;
31647 bool result;
31648 char *kwnames[] = {
31649 NULL
31650 };
31651
31652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
31653 {
31654 PyThreadState* __tstate = wxPyBeginAllowThreads();
31655 result = (bool)wxValidator::IsSilent();
31656
31657 wxPyEndAllowThreads(__tstate);
31658 if (PyErr_Occurred()) SWIG_fail;
31659 }
31660 {
31661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31662 }
31663 return resultobj;
31664 fail:
31665 return NULL;
31666 }
31667
31668
31669 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
31670 PyObject *resultobj;
31671 int arg1 = (int) true ;
31672 PyObject * obj0 = 0 ;
31673 char *kwnames[] = {
31674 (char *) "doIt", NULL
31675 };
31676
31677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
31678 if (obj0) {
31679 {
31680 arg1 = (int)(SWIG_As_int(obj0));
31681 if (SWIG_arg_fail(1)) SWIG_fail;
31682 }
31683 }
31684 {
31685 PyThreadState* __tstate = wxPyBeginAllowThreads();
31686 wxValidator::SetBellOnError(arg1);
31687
31688 wxPyEndAllowThreads(__tstate);
31689 if (PyErr_Occurred()) SWIG_fail;
31690 }
31691 Py_INCREF(Py_None); resultobj = Py_None;
31692 return resultobj;
31693 fail:
31694 return NULL;
31695 }
31696
31697
31698 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
31699 PyObject *obj;
31700 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31701 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
31702 Py_INCREF(obj);
31703 return Py_BuildValue((char *)"");
31704 }
31705 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
31706 PyObject *resultobj;
31707 wxPyValidator *result;
31708 char *kwnames[] = {
31709 NULL
31710 };
31711
31712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
31713 {
31714 PyThreadState* __tstate = wxPyBeginAllowThreads();
31715 result = (wxPyValidator *)new wxPyValidator();
31716
31717 wxPyEndAllowThreads(__tstate);
31718 if (PyErr_Occurred()) SWIG_fail;
31719 }
31720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
31721 return resultobj;
31722 fail:
31723 return NULL;
31724 }
31725
31726
31727 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
31728 PyObject *resultobj;
31729 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
31730 PyObject *arg2 = (PyObject *) 0 ;
31731 PyObject *arg3 = (PyObject *) 0 ;
31732 int arg4 = (int) true ;
31733 PyObject * obj0 = 0 ;
31734 PyObject * obj1 = 0 ;
31735 PyObject * obj2 = 0 ;
31736 PyObject * obj3 = 0 ;
31737 char *kwnames[] = {
31738 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
31739 };
31740
31741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
31743 if (SWIG_arg_fail(1)) SWIG_fail;
31744 arg2 = obj1;
31745 arg3 = obj2;
31746 if (obj3) {
31747 {
31748 arg4 = (int)(SWIG_As_int(obj3));
31749 if (SWIG_arg_fail(4)) SWIG_fail;
31750 }
31751 }
31752 {
31753 PyThreadState* __tstate = wxPyBeginAllowThreads();
31754 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
31755
31756 wxPyEndAllowThreads(__tstate);
31757 if (PyErr_Occurred()) SWIG_fail;
31758 }
31759 Py_INCREF(Py_None); resultobj = Py_None;
31760 return resultobj;
31761 fail:
31762 return NULL;
31763 }
31764
31765
31766 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
31767 PyObject *obj;
31768 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31769 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
31770 Py_INCREF(obj);
31771 return Py_BuildValue((char *)"");
31772 }
31773 static int _wrap_DefaultValidator_set(PyObject *) {
31774 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
31775 return 1;
31776 }
31777
31778
31779 static PyObject *_wrap_DefaultValidator_get(void) {
31780 PyObject *pyobj;
31781
31782 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
31783 return pyobj;
31784 }
31785
31786
31787 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
31788 PyObject *resultobj;
31789 wxString const &arg1_defvalue = wxPyEmptyString ;
31790 wxString *arg1 = (wxString *) &arg1_defvalue ;
31791 long arg2 = (long) 0 ;
31792 wxMenu *result;
31793 bool temp1 = false ;
31794 PyObject * obj0 = 0 ;
31795 PyObject * obj1 = 0 ;
31796 char *kwnames[] = {
31797 (char *) "title",(char *) "style", NULL
31798 };
31799
31800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
31801 if (obj0) {
31802 {
31803 arg1 = wxString_in_helper(obj0);
31804 if (arg1 == NULL) SWIG_fail;
31805 temp1 = true;
31806 }
31807 }
31808 if (obj1) {
31809 {
31810 arg2 = (long)(SWIG_As_long(obj1));
31811 if (SWIG_arg_fail(2)) SWIG_fail;
31812 }
31813 }
31814 {
31815 if (!wxPyCheckForApp()) SWIG_fail;
31816 PyThreadState* __tstate = wxPyBeginAllowThreads();
31817 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
31818
31819 wxPyEndAllowThreads(__tstate);
31820 if (PyErr_Occurred()) SWIG_fail;
31821 }
31822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
31823 {
31824 if (temp1)
31825 delete arg1;
31826 }
31827 return resultobj;
31828 fail:
31829 {
31830 if (temp1)
31831 delete arg1;
31832 }
31833 return NULL;
31834 }
31835
31836
31837 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
31838 PyObject *resultobj;
31839 wxMenu *arg1 = (wxMenu *) 0 ;
31840 int arg2 ;
31841 wxString *arg3 = 0 ;
31842 wxString const &arg4_defvalue = wxPyEmptyString ;
31843 wxString *arg4 = (wxString *) &arg4_defvalue ;
31844 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
31845 wxMenuItem *result;
31846 bool temp3 = false ;
31847 bool temp4 = false ;
31848 PyObject * obj0 = 0 ;
31849 PyObject * obj1 = 0 ;
31850 PyObject * obj2 = 0 ;
31851 PyObject * obj3 = 0 ;
31852 PyObject * obj4 = 0 ;
31853 char *kwnames[] = {
31854 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
31855 };
31856
31857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
31858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31859 if (SWIG_arg_fail(1)) SWIG_fail;
31860 {
31861 arg2 = (int)(SWIG_As_int(obj1));
31862 if (SWIG_arg_fail(2)) SWIG_fail;
31863 }
31864 {
31865 arg3 = wxString_in_helper(obj2);
31866 if (arg3 == NULL) SWIG_fail;
31867 temp3 = true;
31868 }
31869 if (obj3) {
31870 {
31871 arg4 = wxString_in_helper(obj3);
31872 if (arg4 == NULL) SWIG_fail;
31873 temp4 = true;
31874 }
31875 }
31876 if (obj4) {
31877 {
31878 arg5 = (wxItemKind)(SWIG_As_int(obj4));
31879 if (SWIG_arg_fail(5)) SWIG_fail;
31880 }
31881 }
31882 {
31883 PyThreadState* __tstate = wxPyBeginAllowThreads();
31884 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
31885
31886 wxPyEndAllowThreads(__tstate);
31887 if (PyErr_Occurred()) SWIG_fail;
31888 }
31889 {
31890 resultobj = wxPyMake_wxObject(result, 0);
31891 }
31892 {
31893 if (temp3)
31894 delete arg3;
31895 }
31896 {
31897 if (temp4)
31898 delete arg4;
31899 }
31900 return resultobj;
31901 fail:
31902 {
31903 if (temp3)
31904 delete arg3;
31905 }
31906 {
31907 if (temp4)
31908 delete arg4;
31909 }
31910 return NULL;
31911 }
31912
31913
31914 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
31915 PyObject *resultobj;
31916 wxMenu *arg1 = (wxMenu *) 0 ;
31917 wxMenuItem *result;
31918 PyObject * obj0 = 0 ;
31919 char *kwnames[] = {
31920 (char *) "self", NULL
31921 };
31922
31923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
31924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31925 if (SWIG_arg_fail(1)) SWIG_fail;
31926 {
31927 PyThreadState* __tstate = wxPyBeginAllowThreads();
31928 result = (wxMenuItem *)(arg1)->AppendSeparator();
31929
31930 wxPyEndAllowThreads(__tstate);
31931 if (PyErr_Occurred()) SWIG_fail;
31932 }
31933 {
31934 resultobj = wxPyMake_wxObject(result, 0);
31935 }
31936 return resultobj;
31937 fail:
31938 return NULL;
31939 }
31940
31941
31942 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
31943 PyObject *resultobj;
31944 wxMenu *arg1 = (wxMenu *) 0 ;
31945 int arg2 ;
31946 wxString *arg3 = 0 ;
31947 wxString const &arg4_defvalue = wxPyEmptyString ;
31948 wxString *arg4 = (wxString *) &arg4_defvalue ;
31949 wxMenuItem *result;
31950 bool temp3 = false ;
31951 bool temp4 = false ;
31952 PyObject * obj0 = 0 ;
31953 PyObject * obj1 = 0 ;
31954 PyObject * obj2 = 0 ;
31955 PyObject * obj3 = 0 ;
31956 char *kwnames[] = {
31957 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
31958 };
31959
31960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31962 if (SWIG_arg_fail(1)) SWIG_fail;
31963 {
31964 arg2 = (int)(SWIG_As_int(obj1));
31965 if (SWIG_arg_fail(2)) SWIG_fail;
31966 }
31967 {
31968 arg3 = wxString_in_helper(obj2);
31969 if (arg3 == NULL) SWIG_fail;
31970 temp3 = true;
31971 }
31972 if (obj3) {
31973 {
31974 arg4 = wxString_in_helper(obj3);
31975 if (arg4 == NULL) SWIG_fail;
31976 temp4 = true;
31977 }
31978 }
31979 {
31980 PyThreadState* __tstate = wxPyBeginAllowThreads();
31981 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
31982
31983 wxPyEndAllowThreads(__tstate);
31984 if (PyErr_Occurred()) SWIG_fail;
31985 }
31986 {
31987 resultobj = wxPyMake_wxObject(result, 0);
31988 }
31989 {
31990 if (temp3)
31991 delete arg3;
31992 }
31993 {
31994 if (temp4)
31995 delete arg4;
31996 }
31997 return resultobj;
31998 fail:
31999 {
32000 if (temp3)
32001 delete arg3;
32002 }
32003 {
32004 if (temp4)
32005 delete arg4;
32006 }
32007 return NULL;
32008 }
32009
32010
32011 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32012 PyObject *resultobj;
32013 wxMenu *arg1 = (wxMenu *) 0 ;
32014 int arg2 ;
32015 wxString *arg3 = 0 ;
32016 wxString const &arg4_defvalue = wxPyEmptyString ;
32017 wxString *arg4 = (wxString *) &arg4_defvalue ;
32018 wxMenuItem *result;
32019 bool temp3 = false ;
32020 bool temp4 = false ;
32021 PyObject * obj0 = 0 ;
32022 PyObject * obj1 = 0 ;
32023 PyObject * obj2 = 0 ;
32024 PyObject * obj3 = 0 ;
32025 char *kwnames[] = {
32026 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32027 };
32028
32029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32031 if (SWIG_arg_fail(1)) SWIG_fail;
32032 {
32033 arg2 = (int)(SWIG_As_int(obj1));
32034 if (SWIG_arg_fail(2)) SWIG_fail;
32035 }
32036 {
32037 arg3 = wxString_in_helper(obj2);
32038 if (arg3 == NULL) SWIG_fail;
32039 temp3 = true;
32040 }
32041 if (obj3) {
32042 {
32043 arg4 = wxString_in_helper(obj3);
32044 if (arg4 == NULL) SWIG_fail;
32045 temp4 = true;
32046 }
32047 }
32048 {
32049 PyThreadState* __tstate = wxPyBeginAllowThreads();
32050 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32051
32052 wxPyEndAllowThreads(__tstate);
32053 if (PyErr_Occurred()) SWIG_fail;
32054 }
32055 {
32056 resultobj = wxPyMake_wxObject(result, 0);
32057 }
32058 {
32059 if (temp3)
32060 delete arg3;
32061 }
32062 {
32063 if (temp4)
32064 delete arg4;
32065 }
32066 return resultobj;
32067 fail:
32068 {
32069 if (temp3)
32070 delete arg3;
32071 }
32072 {
32073 if (temp4)
32074 delete arg4;
32075 }
32076 return NULL;
32077 }
32078
32079
32080 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32081 PyObject *resultobj;
32082 wxMenu *arg1 = (wxMenu *) 0 ;
32083 int arg2 ;
32084 wxString *arg3 = 0 ;
32085 wxMenu *arg4 = (wxMenu *) 0 ;
32086 wxString const &arg5_defvalue = wxPyEmptyString ;
32087 wxString *arg5 = (wxString *) &arg5_defvalue ;
32088 wxMenuItem *result;
32089 bool temp3 = false ;
32090 bool temp5 = false ;
32091 PyObject * obj0 = 0 ;
32092 PyObject * obj1 = 0 ;
32093 PyObject * obj2 = 0 ;
32094 PyObject * obj3 = 0 ;
32095 PyObject * obj4 = 0 ;
32096 char *kwnames[] = {
32097 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32098 };
32099
32100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32102 if (SWIG_arg_fail(1)) SWIG_fail;
32103 {
32104 arg2 = (int)(SWIG_As_int(obj1));
32105 if (SWIG_arg_fail(2)) SWIG_fail;
32106 }
32107 {
32108 arg3 = wxString_in_helper(obj2);
32109 if (arg3 == NULL) SWIG_fail;
32110 temp3 = true;
32111 }
32112 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32113 if (SWIG_arg_fail(4)) SWIG_fail;
32114 if (obj4) {
32115 {
32116 arg5 = wxString_in_helper(obj4);
32117 if (arg5 == NULL) SWIG_fail;
32118 temp5 = true;
32119 }
32120 }
32121 {
32122 PyThreadState* __tstate = wxPyBeginAllowThreads();
32123 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32124
32125 wxPyEndAllowThreads(__tstate);
32126 if (PyErr_Occurred()) SWIG_fail;
32127 }
32128 {
32129 resultobj = wxPyMake_wxObject(result, 0);
32130 }
32131 {
32132 if (temp3)
32133 delete arg3;
32134 }
32135 {
32136 if (temp5)
32137 delete arg5;
32138 }
32139 return resultobj;
32140 fail:
32141 {
32142 if (temp3)
32143 delete arg3;
32144 }
32145 {
32146 if (temp5)
32147 delete arg5;
32148 }
32149 return NULL;
32150 }
32151
32152
32153 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32154 PyObject *resultobj;
32155 wxMenu *arg1 = (wxMenu *) 0 ;
32156 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32157 wxMenuItem *result;
32158 PyObject * obj0 = 0 ;
32159 PyObject * obj1 = 0 ;
32160 char *kwnames[] = {
32161 (char *) "self",(char *) "item", NULL
32162 };
32163
32164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32166 if (SWIG_arg_fail(1)) SWIG_fail;
32167 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32168 if (SWIG_arg_fail(2)) SWIG_fail;
32169 {
32170 PyThreadState* __tstate = wxPyBeginAllowThreads();
32171 result = (wxMenuItem *)(arg1)->Append(arg2);
32172
32173 wxPyEndAllowThreads(__tstate);
32174 if (PyErr_Occurred()) SWIG_fail;
32175 }
32176 {
32177 resultobj = wxPyMake_wxObject(result, 0);
32178 }
32179 return resultobj;
32180 fail:
32181 return NULL;
32182 }
32183
32184
32185 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32186 PyObject *resultobj;
32187 wxMenu *arg1 = (wxMenu *) 0 ;
32188 PyObject * obj0 = 0 ;
32189 char *kwnames[] = {
32190 (char *) "self", NULL
32191 };
32192
32193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32195 if (SWIG_arg_fail(1)) SWIG_fail;
32196 {
32197 PyThreadState* __tstate = wxPyBeginAllowThreads();
32198 (arg1)->Break();
32199
32200 wxPyEndAllowThreads(__tstate);
32201 if (PyErr_Occurred()) SWIG_fail;
32202 }
32203 Py_INCREF(Py_None); resultobj = Py_None;
32204 return resultobj;
32205 fail:
32206 return NULL;
32207 }
32208
32209
32210 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32211 PyObject *resultobj;
32212 wxMenu *arg1 = (wxMenu *) 0 ;
32213 size_t arg2 ;
32214 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32215 wxMenuItem *result;
32216 PyObject * obj0 = 0 ;
32217 PyObject * obj1 = 0 ;
32218 PyObject * obj2 = 0 ;
32219 char *kwnames[] = {
32220 (char *) "self",(char *) "pos",(char *) "item", NULL
32221 };
32222
32223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32225 if (SWIG_arg_fail(1)) SWIG_fail;
32226 {
32227 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32228 if (SWIG_arg_fail(2)) SWIG_fail;
32229 }
32230 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32231 if (SWIG_arg_fail(3)) SWIG_fail;
32232 {
32233 PyThreadState* __tstate = wxPyBeginAllowThreads();
32234 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32235
32236 wxPyEndAllowThreads(__tstate);
32237 if (PyErr_Occurred()) SWIG_fail;
32238 }
32239 {
32240 resultobj = wxPyMake_wxObject(result, 0);
32241 }
32242 return resultobj;
32243 fail:
32244 return NULL;
32245 }
32246
32247
32248 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32249 PyObject *resultobj;
32250 wxMenu *arg1 = (wxMenu *) 0 ;
32251 size_t arg2 ;
32252 int arg3 ;
32253 wxString *arg4 = 0 ;
32254 wxString const &arg5_defvalue = wxPyEmptyString ;
32255 wxString *arg5 = (wxString *) &arg5_defvalue ;
32256 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32257 wxMenuItem *result;
32258 bool temp4 = false ;
32259 bool temp5 = false ;
32260 PyObject * obj0 = 0 ;
32261 PyObject * obj1 = 0 ;
32262 PyObject * obj2 = 0 ;
32263 PyObject * obj3 = 0 ;
32264 PyObject * obj4 = 0 ;
32265 PyObject * obj5 = 0 ;
32266 char *kwnames[] = {
32267 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32268 };
32269
32270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32272 if (SWIG_arg_fail(1)) SWIG_fail;
32273 {
32274 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32275 if (SWIG_arg_fail(2)) SWIG_fail;
32276 }
32277 {
32278 arg3 = (int)(SWIG_As_int(obj2));
32279 if (SWIG_arg_fail(3)) SWIG_fail;
32280 }
32281 {
32282 arg4 = wxString_in_helper(obj3);
32283 if (arg4 == NULL) SWIG_fail;
32284 temp4 = true;
32285 }
32286 if (obj4) {
32287 {
32288 arg5 = wxString_in_helper(obj4);
32289 if (arg5 == NULL) SWIG_fail;
32290 temp5 = true;
32291 }
32292 }
32293 if (obj5) {
32294 {
32295 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32296 if (SWIG_arg_fail(6)) SWIG_fail;
32297 }
32298 }
32299 {
32300 PyThreadState* __tstate = wxPyBeginAllowThreads();
32301 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32302
32303 wxPyEndAllowThreads(__tstate);
32304 if (PyErr_Occurred()) SWIG_fail;
32305 }
32306 {
32307 resultobj = wxPyMake_wxObject(result, 0);
32308 }
32309 {
32310 if (temp4)
32311 delete arg4;
32312 }
32313 {
32314 if (temp5)
32315 delete arg5;
32316 }
32317 return resultobj;
32318 fail:
32319 {
32320 if (temp4)
32321 delete arg4;
32322 }
32323 {
32324 if (temp5)
32325 delete arg5;
32326 }
32327 return NULL;
32328 }
32329
32330
32331 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32332 PyObject *resultobj;
32333 wxMenu *arg1 = (wxMenu *) 0 ;
32334 size_t arg2 ;
32335 wxMenuItem *result;
32336 PyObject * obj0 = 0 ;
32337 PyObject * obj1 = 0 ;
32338 char *kwnames[] = {
32339 (char *) "self",(char *) "pos", NULL
32340 };
32341
32342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32344 if (SWIG_arg_fail(1)) SWIG_fail;
32345 {
32346 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32347 if (SWIG_arg_fail(2)) SWIG_fail;
32348 }
32349 {
32350 PyThreadState* __tstate = wxPyBeginAllowThreads();
32351 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
32352
32353 wxPyEndAllowThreads(__tstate);
32354 if (PyErr_Occurred()) SWIG_fail;
32355 }
32356 {
32357 resultobj = wxPyMake_wxObject(result, 0);
32358 }
32359 return resultobj;
32360 fail:
32361 return NULL;
32362 }
32363
32364
32365 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32366 PyObject *resultobj;
32367 wxMenu *arg1 = (wxMenu *) 0 ;
32368 size_t arg2 ;
32369 int arg3 ;
32370 wxString *arg4 = 0 ;
32371 wxString const &arg5_defvalue = wxPyEmptyString ;
32372 wxString *arg5 = (wxString *) &arg5_defvalue ;
32373 wxMenuItem *result;
32374 bool temp4 = false ;
32375 bool temp5 = false ;
32376 PyObject * obj0 = 0 ;
32377 PyObject * obj1 = 0 ;
32378 PyObject * obj2 = 0 ;
32379 PyObject * obj3 = 0 ;
32380 PyObject * obj4 = 0 ;
32381 char *kwnames[] = {
32382 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32383 };
32384
32385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32387 if (SWIG_arg_fail(1)) SWIG_fail;
32388 {
32389 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32390 if (SWIG_arg_fail(2)) SWIG_fail;
32391 }
32392 {
32393 arg3 = (int)(SWIG_As_int(obj2));
32394 if (SWIG_arg_fail(3)) SWIG_fail;
32395 }
32396 {
32397 arg4 = wxString_in_helper(obj3);
32398 if (arg4 == NULL) SWIG_fail;
32399 temp4 = true;
32400 }
32401 if (obj4) {
32402 {
32403 arg5 = wxString_in_helper(obj4);
32404 if (arg5 == NULL) SWIG_fail;
32405 temp5 = true;
32406 }
32407 }
32408 {
32409 PyThreadState* __tstate = wxPyBeginAllowThreads();
32410 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32411
32412 wxPyEndAllowThreads(__tstate);
32413 if (PyErr_Occurred()) SWIG_fail;
32414 }
32415 {
32416 resultobj = wxPyMake_wxObject(result, 0);
32417 }
32418 {
32419 if (temp4)
32420 delete arg4;
32421 }
32422 {
32423 if (temp5)
32424 delete arg5;
32425 }
32426 return resultobj;
32427 fail:
32428 {
32429 if (temp4)
32430 delete arg4;
32431 }
32432 {
32433 if (temp5)
32434 delete arg5;
32435 }
32436 return NULL;
32437 }
32438
32439
32440 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32441 PyObject *resultobj;
32442 wxMenu *arg1 = (wxMenu *) 0 ;
32443 size_t arg2 ;
32444 int arg3 ;
32445 wxString *arg4 = 0 ;
32446 wxString const &arg5_defvalue = wxPyEmptyString ;
32447 wxString *arg5 = (wxString *) &arg5_defvalue ;
32448 wxMenuItem *result;
32449 bool temp4 = false ;
32450 bool temp5 = false ;
32451 PyObject * obj0 = 0 ;
32452 PyObject * obj1 = 0 ;
32453 PyObject * obj2 = 0 ;
32454 PyObject * obj3 = 0 ;
32455 PyObject * obj4 = 0 ;
32456 char *kwnames[] = {
32457 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32458 };
32459
32460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32462 if (SWIG_arg_fail(1)) SWIG_fail;
32463 {
32464 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32465 if (SWIG_arg_fail(2)) SWIG_fail;
32466 }
32467 {
32468 arg3 = (int)(SWIG_As_int(obj2));
32469 if (SWIG_arg_fail(3)) SWIG_fail;
32470 }
32471 {
32472 arg4 = wxString_in_helper(obj3);
32473 if (arg4 == NULL) SWIG_fail;
32474 temp4 = true;
32475 }
32476 if (obj4) {
32477 {
32478 arg5 = wxString_in_helper(obj4);
32479 if (arg5 == NULL) SWIG_fail;
32480 temp5 = true;
32481 }
32482 }
32483 {
32484 PyThreadState* __tstate = wxPyBeginAllowThreads();
32485 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32486
32487 wxPyEndAllowThreads(__tstate);
32488 if (PyErr_Occurred()) SWIG_fail;
32489 }
32490 {
32491 resultobj = wxPyMake_wxObject(result, 0);
32492 }
32493 {
32494 if (temp4)
32495 delete arg4;
32496 }
32497 {
32498 if (temp5)
32499 delete arg5;
32500 }
32501 return resultobj;
32502 fail:
32503 {
32504 if (temp4)
32505 delete arg4;
32506 }
32507 {
32508 if (temp5)
32509 delete arg5;
32510 }
32511 return NULL;
32512 }
32513
32514
32515 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32516 PyObject *resultobj;
32517 wxMenu *arg1 = (wxMenu *) 0 ;
32518 size_t arg2 ;
32519 int arg3 ;
32520 wxString *arg4 = 0 ;
32521 wxMenu *arg5 = (wxMenu *) 0 ;
32522 wxString const &arg6_defvalue = wxPyEmptyString ;
32523 wxString *arg6 = (wxString *) &arg6_defvalue ;
32524 wxMenuItem *result;
32525 bool temp4 = false ;
32526 bool temp6 = false ;
32527 PyObject * obj0 = 0 ;
32528 PyObject * obj1 = 0 ;
32529 PyObject * obj2 = 0 ;
32530 PyObject * obj3 = 0 ;
32531 PyObject * obj4 = 0 ;
32532 PyObject * obj5 = 0 ;
32533 char *kwnames[] = {
32534 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32535 };
32536
32537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32539 if (SWIG_arg_fail(1)) SWIG_fail;
32540 {
32541 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32542 if (SWIG_arg_fail(2)) SWIG_fail;
32543 }
32544 {
32545 arg3 = (int)(SWIG_As_int(obj2));
32546 if (SWIG_arg_fail(3)) SWIG_fail;
32547 }
32548 {
32549 arg4 = wxString_in_helper(obj3);
32550 if (arg4 == NULL) SWIG_fail;
32551 temp4 = true;
32552 }
32553 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32554 if (SWIG_arg_fail(5)) SWIG_fail;
32555 if (obj5) {
32556 {
32557 arg6 = wxString_in_helper(obj5);
32558 if (arg6 == NULL) SWIG_fail;
32559 temp6 = true;
32560 }
32561 }
32562 {
32563 PyThreadState* __tstate = wxPyBeginAllowThreads();
32564 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
32565
32566 wxPyEndAllowThreads(__tstate);
32567 if (PyErr_Occurred()) SWIG_fail;
32568 }
32569 {
32570 resultobj = wxPyMake_wxObject(result, 0);
32571 }
32572 {
32573 if (temp4)
32574 delete arg4;
32575 }
32576 {
32577 if (temp6)
32578 delete arg6;
32579 }
32580 return resultobj;
32581 fail:
32582 {
32583 if (temp4)
32584 delete arg4;
32585 }
32586 {
32587 if (temp6)
32588 delete arg6;
32589 }
32590 return NULL;
32591 }
32592
32593
32594 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
32595 PyObject *resultobj;
32596 wxMenu *arg1 = (wxMenu *) 0 ;
32597 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32598 wxMenuItem *result;
32599 PyObject * obj0 = 0 ;
32600 PyObject * obj1 = 0 ;
32601 char *kwnames[] = {
32602 (char *) "self",(char *) "item", NULL
32603 };
32604
32605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
32606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32607 if (SWIG_arg_fail(1)) SWIG_fail;
32608 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32609 if (SWIG_arg_fail(2)) SWIG_fail;
32610 {
32611 PyThreadState* __tstate = wxPyBeginAllowThreads();
32612 result = (wxMenuItem *)(arg1)->Prepend(arg2);
32613
32614 wxPyEndAllowThreads(__tstate);
32615 if (PyErr_Occurred()) SWIG_fail;
32616 }
32617 {
32618 resultobj = wxPyMake_wxObject(result, 0);
32619 }
32620 return resultobj;
32621 fail:
32622 return NULL;
32623 }
32624
32625
32626 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
32627 PyObject *resultobj;
32628 wxMenu *arg1 = (wxMenu *) 0 ;
32629 int arg2 ;
32630 wxString *arg3 = 0 ;
32631 wxString const &arg4_defvalue = wxPyEmptyString ;
32632 wxString *arg4 = (wxString *) &arg4_defvalue ;
32633 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32634 wxMenuItem *result;
32635 bool temp3 = false ;
32636 bool temp4 = false ;
32637 PyObject * obj0 = 0 ;
32638 PyObject * obj1 = 0 ;
32639 PyObject * obj2 = 0 ;
32640 PyObject * obj3 = 0 ;
32641 PyObject * obj4 = 0 ;
32642 char *kwnames[] = {
32643 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32644 };
32645
32646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32648 if (SWIG_arg_fail(1)) SWIG_fail;
32649 {
32650 arg2 = (int)(SWIG_As_int(obj1));
32651 if (SWIG_arg_fail(2)) SWIG_fail;
32652 }
32653 {
32654 arg3 = wxString_in_helper(obj2);
32655 if (arg3 == NULL) SWIG_fail;
32656 temp3 = true;
32657 }
32658 if (obj3) {
32659 {
32660 arg4 = wxString_in_helper(obj3);
32661 if (arg4 == NULL) SWIG_fail;
32662 temp4 = true;
32663 }
32664 }
32665 if (obj4) {
32666 {
32667 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32668 if (SWIG_arg_fail(5)) SWIG_fail;
32669 }
32670 }
32671 {
32672 PyThreadState* __tstate = wxPyBeginAllowThreads();
32673 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32674
32675 wxPyEndAllowThreads(__tstate);
32676 if (PyErr_Occurred()) SWIG_fail;
32677 }
32678 {
32679 resultobj = wxPyMake_wxObject(result, 0);
32680 }
32681 {
32682 if (temp3)
32683 delete arg3;
32684 }
32685 {
32686 if (temp4)
32687 delete arg4;
32688 }
32689 return resultobj;
32690 fail:
32691 {
32692 if (temp3)
32693 delete arg3;
32694 }
32695 {
32696 if (temp4)
32697 delete arg4;
32698 }
32699 return NULL;
32700 }
32701
32702
32703 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32704 PyObject *resultobj;
32705 wxMenu *arg1 = (wxMenu *) 0 ;
32706 wxMenuItem *result;
32707 PyObject * obj0 = 0 ;
32708 char *kwnames[] = {
32709 (char *) "self", NULL
32710 };
32711
32712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
32713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32714 if (SWIG_arg_fail(1)) SWIG_fail;
32715 {
32716 PyThreadState* __tstate = wxPyBeginAllowThreads();
32717 result = (wxMenuItem *)(arg1)->PrependSeparator();
32718
32719 wxPyEndAllowThreads(__tstate);
32720 if (PyErr_Occurred()) SWIG_fail;
32721 }
32722 {
32723 resultobj = wxPyMake_wxObject(result, 0);
32724 }
32725 return resultobj;
32726 fail:
32727 return NULL;
32728 }
32729
32730
32731 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32732 PyObject *resultobj;
32733 wxMenu *arg1 = (wxMenu *) 0 ;
32734 int arg2 ;
32735 wxString *arg3 = 0 ;
32736 wxString const &arg4_defvalue = wxPyEmptyString ;
32737 wxString *arg4 = (wxString *) &arg4_defvalue ;
32738 wxMenuItem *result;
32739 bool temp3 = false ;
32740 bool temp4 = false ;
32741 PyObject * obj0 = 0 ;
32742 PyObject * obj1 = 0 ;
32743 PyObject * obj2 = 0 ;
32744 PyObject * obj3 = 0 ;
32745 char *kwnames[] = {
32746 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32747 };
32748
32749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32751 if (SWIG_arg_fail(1)) SWIG_fail;
32752 {
32753 arg2 = (int)(SWIG_As_int(obj1));
32754 if (SWIG_arg_fail(2)) SWIG_fail;
32755 }
32756 {
32757 arg3 = wxString_in_helper(obj2);
32758 if (arg3 == NULL) SWIG_fail;
32759 temp3 = true;
32760 }
32761 if (obj3) {
32762 {
32763 arg4 = wxString_in_helper(obj3);
32764 if (arg4 == NULL) SWIG_fail;
32765 temp4 = true;
32766 }
32767 }
32768 {
32769 PyThreadState* __tstate = wxPyBeginAllowThreads();
32770 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32771
32772 wxPyEndAllowThreads(__tstate);
32773 if (PyErr_Occurred()) SWIG_fail;
32774 }
32775 {
32776 resultobj = wxPyMake_wxObject(result, 0);
32777 }
32778 {
32779 if (temp3)
32780 delete arg3;
32781 }
32782 {
32783 if (temp4)
32784 delete arg4;
32785 }
32786 return resultobj;
32787 fail:
32788 {
32789 if (temp3)
32790 delete arg3;
32791 }
32792 {
32793 if (temp4)
32794 delete arg4;
32795 }
32796 return NULL;
32797 }
32798
32799
32800 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32801 PyObject *resultobj;
32802 wxMenu *arg1 = (wxMenu *) 0 ;
32803 int arg2 ;
32804 wxString *arg3 = 0 ;
32805 wxString const &arg4_defvalue = wxPyEmptyString ;
32806 wxString *arg4 = (wxString *) &arg4_defvalue ;
32807 wxMenuItem *result;
32808 bool temp3 = false ;
32809 bool temp4 = false ;
32810 PyObject * obj0 = 0 ;
32811 PyObject * obj1 = 0 ;
32812 PyObject * obj2 = 0 ;
32813 PyObject * obj3 = 0 ;
32814 char *kwnames[] = {
32815 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32816 };
32817
32818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32820 if (SWIG_arg_fail(1)) SWIG_fail;
32821 {
32822 arg2 = (int)(SWIG_As_int(obj1));
32823 if (SWIG_arg_fail(2)) SWIG_fail;
32824 }
32825 {
32826 arg3 = wxString_in_helper(obj2);
32827 if (arg3 == NULL) SWIG_fail;
32828 temp3 = true;
32829 }
32830 if (obj3) {
32831 {
32832 arg4 = wxString_in_helper(obj3);
32833 if (arg4 == NULL) SWIG_fail;
32834 temp4 = true;
32835 }
32836 }
32837 {
32838 PyThreadState* __tstate = wxPyBeginAllowThreads();
32839 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32840
32841 wxPyEndAllowThreads(__tstate);
32842 if (PyErr_Occurred()) SWIG_fail;
32843 }
32844 {
32845 resultobj = wxPyMake_wxObject(result, 0);
32846 }
32847 {
32848 if (temp3)
32849 delete arg3;
32850 }
32851 {
32852 if (temp4)
32853 delete arg4;
32854 }
32855 return resultobj;
32856 fail:
32857 {
32858 if (temp3)
32859 delete arg3;
32860 }
32861 {
32862 if (temp4)
32863 delete arg4;
32864 }
32865 return NULL;
32866 }
32867
32868
32869 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32870 PyObject *resultobj;
32871 wxMenu *arg1 = (wxMenu *) 0 ;
32872 int arg2 ;
32873 wxString *arg3 = 0 ;
32874 wxMenu *arg4 = (wxMenu *) 0 ;
32875 wxString const &arg5_defvalue = wxPyEmptyString ;
32876 wxString *arg5 = (wxString *) &arg5_defvalue ;
32877 wxMenuItem *result;
32878 bool temp3 = false ;
32879 bool temp5 = false ;
32880 PyObject * obj0 = 0 ;
32881 PyObject * obj1 = 0 ;
32882 PyObject * obj2 = 0 ;
32883 PyObject * obj3 = 0 ;
32884 PyObject * obj4 = 0 ;
32885 char *kwnames[] = {
32886 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32887 };
32888
32889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32891 if (SWIG_arg_fail(1)) SWIG_fail;
32892 {
32893 arg2 = (int)(SWIG_As_int(obj1));
32894 if (SWIG_arg_fail(2)) SWIG_fail;
32895 }
32896 {
32897 arg3 = wxString_in_helper(obj2);
32898 if (arg3 == NULL) SWIG_fail;
32899 temp3 = true;
32900 }
32901 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32902 if (SWIG_arg_fail(4)) SWIG_fail;
32903 if (obj4) {
32904 {
32905 arg5 = wxString_in_helper(obj4);
32906 if (arg5 == NULL) SWIG_fail;
32907 temp5 = true;
32908 }
32909 }
32910 {
32911 PyThreadState* __tstate = wxPyBeginAllowThreads();
32912 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32913
32914 wxPyEndAllowThreads(__tstate);
32915 if (PyErr_Occurred()) SWIG_fail;
32916 }
32917 {
32918 resultobj = wxPyMake_wxObject(result, 0);
32919 }
32920 {
32921 if (temp3)
32922 delete arg3;
32923 }
32924 {
32925 if (temp5)
32926 delete arg5;
32927 }
32928 return resultobj;
32929 fail:
32930 {
32931 if (temp3)
32932 delete arg3;
32933 }
32934 {
32935 if (temp5)
32936 delete arg5;
32937 }
32938 return NULL;
32939 }
32940
32941
32942 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
32943 PyObject *resultobj;
32944 wxMenu *arg1 = (wxMenu *) 0 ;
32945 int arg2 ;
32946 wxMenuItem *result;
32947 PyObject * obj0 = 0 ;
32948 PyObject * obj1 = 0 ;
32949 char *kwnames[] = {
32950 (char *) "self",(char *) "id", NULL
32951 };
32952
32953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
32954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32955 if (SWIG_arg_fail(1)) SWIG_fail;
32956 {
32957 arg2 = (int)(SWIG_As_int(obj1));
32958 if (SWIG_arg_fail(2)) SWIG_fail;
32959 }
32960 {
32961 PyThreadState* __tstate = wxPyBeginAllowThreads();
32962 result = (wxMenuItem *)(arg1)->Remove(arg2);
32963
32964 wxPyEndAllowThreads(__tstate);
32965 if (PyErr_Occurred()) SWIG_fail;
32966 }
32967 {
32968 resultobj = wxPyMake_wxObject(result, 0);
32969 }
32970 return resultobj;
32971 fail:
32972 return NULL;
32973 }
32974
32975
32976 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
32977 PyObject *resultobj;
32978 wxMenu *arg1 = (wxMenu *) 0 ;
32979 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32980 wxMenuItem *result;
32981 PyObject * obj0 = 0 ;
32982 PyObject * obj1 = 0 ;
32983 char *kwnames[] = {
32984 (char *) "self",(char *) "item", NULL
32985 };
32986
32987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
32988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32989 if (SWIG_arg_fail(1)) SWIG_fail;
32990 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32991 if (SWIG_arg_fail(2)) SWIG_fail;
32992 {
32993 PyThreadState* __tstate = wxPyBeginAllowThreads();
32994 result = (wxMenuItem *)(arg1)->Remove(arg2);
32995
32996 wxPyEndAllowThreads(__tstate);
32997 if (PyErr_Occurred()) SWIG_fail;
32998 }
32999 {
33000 resultobj = wxPyMake_wxObject(result, 0);
33001 }
33002 return resultobj;
33003 fail:
33004 return NULL;
33005 }
33006
33007
33008 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33009 PyObject *resultobj;
33010 wxMenu *arg1 = (wxMenu *) 0 ;
33011 int arg2 ;
33012 bool result;
33013 PyObject * obj0 = 0 ;
33014 PyObject * obj1 = 0 ;
33015 char *kwnames[] = {
33016 (char *) "self",(char *) "id", NULL
33017 };
33018
33019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33021 if (SWIG_arg_fail(1)) SWIG_fail;
33022 {
33023 arg2 = (int)(SWIG_As_int(obj1));
33024 if (SWIG_arg_fail(2)) SWIG_fail;
33025 }
33026 {
33027 PyThreadState* __tstate = wxPyBeginAllowThreads();
33028 result = (bool)(arg1)->Delete(arg2);
33029
33030 wxPyEndAllowThreads(__tstate);
33031 if (PyErr_Occurred()) SWIG_fail;
33032 }
33033 {
33034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33035 }
33036 return resultobj;
33037 fail:
33038 return NULL;
33039 }
33040
33041
33042 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33043 PyObject *resultobj;
33044 wxMenu *arg1 = (wxMenu *) 0 ;
33045 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33046 bool result;
33047 PyObject * obj0 = 0 ;
33048 PyObject * obj1 = 0 ;
33049 char *kwnames[] = {
33050 (char *) "self",(char *) "item", NULL
33051 };
33052
33053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33055 if (SWIG_arg_fail(1)) SWIG_fail;
33056 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33057 if (SWIG_arg_fail(2)) SWIG_fail;
33058 {
33059 PyThreadState* __tstate = wxPyBeginAllowThreads();
33060 result = (bool)(arg1)->Delete(arg2);
33061
33062 wxPyEndAllowThreads(__tstate);
33063 if (PyErr_Occurred()) SWIG_fail;
33064 }
33065 {
33066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33067 }
33068 return resultobj;
33069 fail:
33070 return NULL;
33071 }
33072
33073
33074 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33075 PyObject *resultobj;
33076 wxMenu *arg1 = (wxMenu *) 0 ;
33077 PyObject * obj0 = 0 ;
33078 char *kwnames[] = {
33079 (char *) "self", NULL
33080 };
33081
33082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33084 if (SWIG_arg_fail(1)) SWIG_fail;
33085 {
33086 PyThreadState* __tstate = wxPyBeginAllowThreads();
33087 wxMenu_Destroy(arg1);
33088
33089 wxPyEndAllowThreads(__tstate);
33090 if (PyErr_Occurred()) SWIG_fail;
33091 }
33092 Py_INCREF(Py_None); resultobj = Py_None;
33093 return resultobj;
33094 fail:
33095 return NULL;
33096 }
33097
33098
33099 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33100 PyObject *resultobj;
33101 wxMenu *arg1 = (wxMenu *) 0 ;
33102 int arg2 ;
33103 bool result;
33104 PyObject * obj0 = 0 ;
33105 PyObject * obj1 = 0 ;
33106 char *kwnames[] = {
33107 (char *) "self",(char *) "id", NULL
33108 };
33109
33110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33112 if (SWIG_arg_fail(1)) SWIG_fail;
33113 {
33114 arg2 = (int)(SWIG_As_int(obj1));
33115 if (SWIG_arg_fail(2)) SWIG_fail;
33116 }
33117 {
33118 PyThreadState* __tstate = wxPyBeginAllowThreads();
33119 result = (bool)(arg1)->Destroy(arg2);
33120
33121 wxPyEndAllowThreads(__tstate);
33122 if (PyErr_Occurred()) SWIG_fail;
33123 }
33124 {
33125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33126 }
33127 return resultobj;
33128 fail:
33129 return NULL;
33130 }
33131
33132
33133 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33134 PyObject *resultobj;
33135 wxMenu *arg1 = (wxMenu *) 0 ;
33136 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33137 bool result;
33138 PyObject * obj0 = 0 ;
33139 PyObject * obj1 = 0 ;
33140 char *kwnames[] = {
33141 (char *) "self",(char *) "item", NULL
33142 };
33143
33144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33146 if (SWIG_arg_fail(1)) SWIG_fail;
33147 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33148 if (SWIG_arg_fail(2)) SWIG_fail;
33149 {
33150 PyThreadState* __tstate = wxPyBeginAllowThreads();
33151 result = (bool)(arg1)->Destroy(arg2);
33152
33153 wxPyEndAllowThreads(__tstate);
33154 if (PyErr_Occurred()) SWIG_fail;
33155 }
33156 {
33157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33158 }
33159 return resultobj;
33160 fail:
33161 return NULL;
33162 }
33163
33164
33165 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33166 PyObject *resultobj;
33167 wxMenu *arg1 = (wxMenu *) 0 ;
33168 size_t result;
33169 PyObject * obj0 = 0 ;
33170 char *kwnames[] = {
33171 (char *) "self", NULL
33172 };
33173
33174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33176 if (SWIG_arg_fail(1)) SWIG_fail;
33177 {
33178 PyThreadState* __tstate = wxPyBeginAllowThreads();
33179 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33180
33181 wxPyEndAllowThreads(__tstate);
33182 if (PyErr_Occurred()) SWIG_fail;
33183 }
33184 {
33185 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33186 }
33187 return resultobj;
33188 fail:
33189 return NULL;
33190 }
33191
33192
33193 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33194 PyObject *resultobj;
33195 wxMenu *arg1 = (wxMenu *) 0 ;
33196 PyObject *result;
33197 PyObject * obj0 = 0 ;
33198 char *kwnames[] = {
33199 (char *) "self", NULL
33200 };
33201
33202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33204 if (SWIG_arg_fail(1)) SWIG_fail;
33205 {
33206 PyThreadState* __tstate = wxPyBeginAllowThreads();
33207 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33208
33209 wxPyEndAllowThreads(__tstate);
33210 if (PyErr_Occurred()) SWIG_fail;
33211 }
33212 resultobj = result;
33213 return resultobj;
33214 fail:
33215 return NULL;
33216 }
33217
33218
33219 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33220 PyObject *resultobj;
33221 wxMenu *arg1 = (wxMenu *) 0 ;
33222 wxString *arg2 = 0 ;
33223 int result;
33224 bool temp2 = false ;
33225 PyObject * obj0 = 0 ;
33226 PyObject * obj1 = 0 ;
33227 char *kwnames[] = {
33228 (char *) "self",(char *) "item", NULL
33229 };
33230
33231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33233 if (SWIG_arg_fail(1)) SWIG_fail;
33234 {
33235 arg2 = wxString_in_helper(obj1);
33236 if (arg2 == NULL) SWIG_fail;
33237 temp2 = true;
33238 }
33239 {
33240 PyThreadState* __tstate = wxPyBeginAllowThreads();
33241 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33242
33243 wxPyEndAllowThreads(__tstate);
33244 if (PyErr_Occurred()) SWIG_fail;
33245 }
33246 {
33247 resultobj = SWIG_From_int((int)(result));
33248 }
33249 {
33250 if (temp2)
33251 delete arg2;
33252 }
33253 return resultobj;
33254 fail:
33255 {
33256 if (temp2)
33257 delete arg2;
33258 }
33259 return NULL;
33260 }
33261
33262
33263 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33264 PyObject *resultobj;
33265 wxMenu *arg1 = (wxMenu *) 0 ;
33266 int arg2 ;
33267 wxMenuItem *result;
33268 PyObject * obj0 = 0 ;
33269 PyObject * obj1 = 0 ;
33270 char *kwnames[] = {
33271 (char *) "self",(char *) "id", NULL
33272 };
33273
33274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
33275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33276 if (SWIG_arg_fail(1)) SWIG_fail;
33277 {
33278 arg2 = (int)(SWIG_As_int(obj1));
33279 if (SWIG_arg_fail(2)) SWIG_fail;
33280 }
33281 {
33282 PyThreadState* __tstate = wxPyBeginAllowThreads();
33283 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33284
33285 wxPyEndAllowThreads(__tstate);
33286 if (PyErr_Occurred()) SWIG_fail;
33287 }
33288 {
33289 resultobj = wxPyMake_wxObject(result, 0);
33290 }
33291 return resultobj;
33292 fail:
33293 return NULL;
33294 }
33295
33296
33297 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33298 PyObject *resultobj;
33299 wxMenu *arg1 = (wxMenu *) 0 ;
33300 size_t arg2 ;
33301 wxMenuItem *result;
33302 PyObject * obj0 = 0 ;
33303 PyObject * obj1 = 0 ;
33304 char *kwnames[] = {
33305 (char *) "self",(char *) "position", NULL
33306 };
33307
33308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33310 if (SWIG_arg_fail(1)) SWIG_fail;
33311 {
33312 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33313 if (SWIG_arg_fail(2)) SWIG_fail;
33314 }
33315 {
33316 PyThreadState* __tstate = wxPyBeginAllowThreads();
33317 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33318
33319 wxPyEndAllowThreads(__tstate);
33320 if (PyErr_Occurred()) SWIG_fail;
33321 }
33322 {
33323 resultobj = wxPyMake_wxObject(result, 0);
33324 }
33325 return resultobj;
33326 fail:
33327 return NULL;
33328 }
33329
33330
33331 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33332 PyObject *resultobj;
33333 wxMenu *arg1 = (wxMenu *) 0 ;
33334 int arg2 ;
33335 bool arg3 ;
33336 PyObject * obj0 = 0 ;
33337 PyObject * obj1 = 0 ;
33338 PyObject * obj2 = 0 ;
33339 char *kwnames[] = {
33340 (char *) "self",(char *) "id",(char *) "enable", NULL
33341 };
33342
33343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33345 if (SWIG_arg_fail(1)) SWIG_fail;
33346 {
33347 arg2 = (int)(SWIG_As_int(obj1));
33348 if (SWIG_arg_fail(2)) SWIG_fail;
33349 }
33350 {
33351 arg3 = (bool)(SWIG_As_bool(obj2));
33352 if (SWIG_arg_fail(3)) SWIG_fail;
33353 }
33354 {
33355 PyThreadState* __tstate = wxPyBeginAllowThreads();
33356 (arg1)->Enable(arg2,arg3);
33357
33358 wxPyEndAllowThreads(__tstate);
33359 if (PyErr_Occurred()) SWIG_fail;
33360 }
33361 Py_INCREF(Py_None); resultobj = Py_None;
33362 return resultobj;
33363 fail:
33364 return NULL;
33365 }
33366
33367
33368 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
33369 PyObject *resultobj;
33370 wxMenu *arg1 = (wxMenu *) 0 ;
33371 int arg2 ;
33372 bool result;
33373 PyObject * obj0 = 0 ;
33374 PyObject * obj1 = 0 ;
33375 char *kwnames[] = {
33376 (char *) "self",(char *) "id", NULL
33377 };
33378
33379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
33380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33381 if (SWIG_arg_fail(1)) SWIG_fail;
33382 {
33383 arg2 = (int)(SWIG_As_int(obj1));
33384 if (SWIG_arg_fail(2)) SWIG_fail;
33385 }
33386 {
33387 PyThreadState* __tstate = wxPyBeginAllowThreads();
33388 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
33389
33390 wxPyEndAllowThreads(__tstate);
33391 if (PyErr_Occurred()) SWIG_fail;
33392 }
33393 {
33394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33395 }
33396 return resultobj;
33397 fail:
33398 return NULL;
33399 }
33400
33401
33402 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
33403 PyObject *resultobj;
33404 wxMenu *arg1 = (wxMenu *) 0 ;
33405 int arg2 ;
33406 bool arg3 ;
33407 PyObject * obj0 = 0 ;
33408 PyObject * obj1 = 0 ;
33409 PyObject * obj2 = 0 ;
33410 char *kwnames[] = {
33411 (char *) "self",(char *) "id",(char *) "check", NULL
33412 };
33413
33414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
33415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33416 if (SWIG_arg_fail(1)) SWIG_fail;
33417 {
33418 arg2 = (int)(SWIG_As_int(obj1));
33419 if (SWIG_arg_fail(2)) SWIG_fail;
33420 }
33421 {
33422 arg3 = (bool)(SWIG_As_bool(obj2));
33423 if (SWIG_arg_fail(3)) SWIG_fail;
33424 }
33425 {
33426 PyThreadState* __tstate = wxPyBeginAllowThreads();
33427 (arg1)->Check(arg2,arg3);
33428
33429 wxPyEndAllowThreads(__tstate);
33430 if (PyErr_Occurred()) SWIG_fail;
33431 }
33432 Py_INCREF(Py_None); resultobj = Py_None;
33433 return resultobj;
33434 fail:
33435 return NULL;
33436 }
33437
33438
33439 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
33440 PyObject *resultobj;
33441 wxMenu *arg1 = (wxMenu *) 0 ;
33442 int arg2 ;
33443 bool result;
33444 PyObject * obj0 = 0 ;
33445 PyObject * obj1 = 0 ;
33446 char *kwnames[] = {
33447 (char *) "self",(char *) "id", NULL
33448 };
33449
33450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
33451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33452 if (SWIG_arg_fail(1)) SWIG_fail;
33453 {
33454 arg2 = (int)(SWIG_As_int(obj1));
33455 if (SWIG_arg_fail(2)) SWIG_fail;
33456 }
33457 {
33458 PyThreadState* __tstate = wxPyBeginAllowThreads();
33459 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
33460
33461 wxPyEndAllowThreads(__tstate);
33462 if (PyErr_Occurred()) SWIG_fail;
33463 }
33464 {
33465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33466 }
33467 return resultobj;
33468 fail:
33469 return NULL;
33470 }
33471
33472
33473 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33474 PyObject *resultobj;
33475 wxMenu *arg1 = (wxMenu *) 0 ;
33476 int arg2 ;
33477 wxString *arg3 = 0 ;
33478 bool temp3 = false ;
33479 PyObject * obj0 = 0 ;
33480 PyObject * obj1 = 0 ;
33481 PyObject * obj2 = 0 ;
33482 char *kwnames[] = {
33483 (char *) "self",(char *) "id",(char *) "label", NULL
33484 };
33485
33486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
33487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33488 if (SWIG_arg_fail(1)) SWIG_fail;
33489 {
33490 arg2 = (int)(SWIG_As_int(obj1));
33491 if (SWIG_arg_fail(2)) SWIG_fail;
33492 }
33493 {
33494 arg3 = wxString_in_helper(obj2);
33495 if (arg3 == NULL) SWIG_fail;
33496 temp3 = true;
33497 }
33498 {
33499 PyThreadState* __tstate = wxPyBeginAllowThreads();
33500 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
33501
33502 wxPyEndAllowThreads(__tstate);
33503 if (PyErr_Occurred()) SWIG_fail;
33504 }
33505 Py_INCREF(Py_None); resultobj = Py_None;
33506 {
33507 if (temp3)
33508 delete arg3;
33509 }
33510 return resultobj;
33511 fail:
33512 {
33513 if (temp3)
33514 delete arg3;
33515 }
33516 return NULL;
33517 }
33518
33519
33520 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33521 PyObject *resultobj;
33522 wxMenu *arg1 = (wxMenu *) 0 ;
33523 int arg2 ;
33524 wxString result;
33525 PyObject * obj0 = 0 ;
33526 PyObject * obj1 = 0 ;
33527 char *kwnames[] = {
33528 (char *) "self",(char *) "id", NULL
33529 };
33530
33531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
33532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33533 if (SWIG_arg_fail(1)) SWIG_fail;
33534 {
33535 arg2 = (int)(SWIG_As_int(obj1));
33536 if (SWIG_arg_fail(2)) SWIG_fail;
33537 }
33538 {
33539 PyThreadState* __tstate = wxPyBeginAllowThreads();
33540 result = ((wxMenu const *)arg1)->GetLabel(arg2);
33541
33542 wxPyEndAllowThreads(__tstate);
33543 if (PyErr_Occurred()) SWIG_fail;
33544 }
33545 {
33546 #if wxUSE_UNICODE
33547 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33548 #else
33549 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33550 #endif
33551 }
33552 return resultobj;
33553 fail:
33554 return NULL;
33555 }
33556
33557
33558 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33559 PyObject *resultobj;
33560 wxMenu *arg1 = (wxMenu *) 0 ;
33561 int arg2 ;
33562 wxString *arg3 = 0 ;
33563 bool temp3 = false ;
33564 PyObject * obj0 = 0 ;
33565 PyObject * obj1 = 0 ;
33566 PyObject * obj2 = 0 ;
33567 char *kwnames[] = {
33568 (char *) "self",(char *) "id",(char *) "helpString", NULL
33569 };
33570
33571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
33572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33573 if (SWIG_arg_fail(1)) SWIG_fail;
33574 {
33575 arg2 = (int)(SWIG_As_int(obj1));
33576 if (SWIG_arg_fail(2)) SWIG_fail;
33577 }
33578 {
33579 arg3 = wxString_in_helper(obj2);
33580 if (arg3 == NULL) SWIG_fail;
33581 temp3 = true;
33582 }
33583 {
33584 PyThreadState* __tstate = wxPyBeginAllowThreads();
33585 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
33586
33587 wxPyEndAllowThreads(__tstate);
33588 if (PyErr_Occurred()) SWIG_fail;
33589 }
33590 Py_INCREF(Py_None); resultobj = Py_None;
33591 {
33592 if (temp3)
33593 delete arg3;
33594 }
33595 return resultobj;
33596 fail:
33597 {
33598 if (temp3)
33599 delete arg3;
33600 }
33601 return NULL;
33602 }
33603
33604
33605 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33606 PyObject *resultobj;
33607 wxMenu *arg1 = (wxMenu *) 0 ;
33608 int arg2 ;
33609 wxString result;
33610 PyObject * obj0 = 0 ;
33611 PyObject * obj1 = 0 ;
33612 char *kwnames[] = {
33613 (char *) "self",(char *) "id", NULL
33614 };
33615
33616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
33617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33618 if (SWIG_arg_fail(1)) SWIG_fail;
33619 {
33620 arg2 = (int)(SWIG_As_int(obj1));
33621 if (SWIG_arg_fail(2)) SWIG_fail;
33622 }
33623 {
33624 PyThreadState* __tstate = wxPyBeginAllowThreads();
33625 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
33626
33627 wxPyEndAllowThreads(__tstate);
33628 if (PyErr_Occurred()) SWIG_fail;
33629 }
33630 {
33631 #if wxUSE_UNICODE
33632 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33633 #else
33634 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33635 #endif
33636 }
33637 return resultobj;
33638 fail:
33639 return NULL;
33640 }
33641
33642
33643 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33644 PyObject *resultobj;
33645 wxMenu *arg1 = (wxMenu *) 0 ;
33646 wxString *arg2 = 0 ;
33647 bool temp2 = false ;
33648 PyObject * obj0 = 0 ;
33649 PyObject * obj1 = 0 ;
33650 char *kwnames[] = {
33651 (char *) "self",(char *) "title", NULL
33652 };
33653
33654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
33655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33656 if (SWIG_arg_fail(1)) SWIG_fail;
33657 {
33658 arg2 = wxString_in_helper(obj1);
33659 if (arg2 == NULL) SWIG_fail;
33660 temp2 = true;
33661 }
33662 {
33663 PyThreadState* __tstate = wxPyBeginAllowThreads();
33664 (arg1)->SetTitle((wxString const &)*arg2);
33665
33666 wxPyEndAllowThreads(__tstate);
33667 if (PyErr_Occurred()) SWIG_fail;
33668 }
33669 Py_INCREF(Py_None); resultobj = Py_None;
33670 {
33671 if (temp2)
33672 delete arg2;
33673 }
33674 return resultobj;
33675 fail:
33676 {
33677 if (temp2)
33678 delete arg2;
33679 }
33680 return NULL;
33681 }
33682
33683
33684 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33685 PyObject *resultobj;
33686 wxMenu *arg1 = (wxMenu *) 0 ;
33687 wxString result;
33688 PyObject * obj0 = 0 ;
33689 char *kwnames[] = {
33690 (char *) "self", NULL
33691 };
33692
33693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
33694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33695 if (SWIG_arg_fail(1)) SWIG_fail;
33696 {
33697 PyThreadState* __tstate = wxPyBeginAllowThreads();
33698 result = ((wxMenu const *)arg1)->GetTitle();
33699
33700 wxPyEndAllowThreads(__tstate);
33701 if (PyErr_Occurred()) SWIG_fail;
33702 }
33703 {
33704 #if wxUSE_UNICODE
33705 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33706 #else
33707 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33708 #endif
33709 }
33710 return resultobj;
33711 fail:
33712 return NULL;
33713 }
33714
33715
33716 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33717 PyObject *resultobj;
33718 wxMenu *arg1 = (wxMenu *) 0 ;
33719 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33720 PyObject * obj0 = 0 ;
33721 PyObject * obj1 = 0 ;
33722 char *kwnames[] = {
33723 (char *) "self",(char *) "handler", NULL
33724 };
33725
33726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
33727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33728 if (SWIG_arg_fail(1)) SWIG_fail;
33729 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
33730 if (SWIG_arg_fail(2)) SWIG_fail;
33731 {
33732 PyThreadState* __tstate = wxPyBeginAllowThreads();
33733 (arg1)->SetEventHandler(arg2);
33734
33735 wxPyEndAllowThreads(__tstate);
33736 if (PyErr_Occurred()) SWIG_fail;
33737 }
33738 Py_INCREF(Py_None); resultobj = Py_None;
33739 return resultobj;
33740 fail:
33741 return NULL;
33742 }
33743
33744
33745 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33746 PyObject *resultobj;
33747 wxMenu *arg1 = (wxMenu *) 0 ;
33748 wxEvtHandler *result;
33749 PyObject * obj0 = 0 ;
33750 char *kwnames[] = {
33751 (char *) "self", NULL
33752 };
33753
33754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
33755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33756 if (SWIG_arg_fail(1)) SWIG_fail;
33757 {
33758 PyThreadState* __tstate = wxPyBeginAllowThreads();
33759 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
33760
33761 wxPyEndAllowThreads(__tstate);
33762 if (PyErr_Occurred()) SWIG_fail;
33763 }
33764 {
33765 resultobj = wxPyMake_wxObject(result, 0);
33766 }
33767 return resultobj;
33768 fail:
33769 return NULL;
33770 }
33771
33772
33773 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33774 PyObject *resultobj;
33775 wxMenu *arg1 = (wxMenu *) 0 ;
33776 wxWindow *arg2 = (wxWindow *) 0 ;
33777 PyObject * obj0 = 0 ;
33778 PyObject * obj1 = 0 ;
33779 char *kwnames[] = {
33780 (char *) "self",(char *) "win", NULL
33781 };
33782
33783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
33784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33785 if (SWIG_arg_fail(1)) SWIG_fail;
33786 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33787 if (SWIG_arg_fail(2)) SWIG_fail;
33788 {
33789 PyThreadState* __tstate = wxPyBeginAllowThreads();
33790 (arg1)->SetInvokingWindow(arg2);
33791
33792 wxPyEndAllowThreads(__tstate);
33793 if (PyErr_Occurred()) SWIG_fail;
33794 }
33795 Py_INCREF(Py_None); resultobj = Py_None;
33796 return resultobj;
33797 fail:
33798 return NULL;
33799 }
33800
33801
33802 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33803 PyObject *resultobj;
33804 wxMenu *arg1 = (wxMenu *) 0 ;
33805 wxWindow *result;
33806 PyObject * obj0 = 0 ;
33807 char *kwnames[] = {
33808 (char *) "self", NULL
33809 };
33810
33811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
33812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33813 if (SWIG_arg_fail(1)) SWIG_fail;
33814 {
33815 PyThreadState* __tstate = wxPyBeginAllowThreads();
33816 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
33817
33818 wxPyEndAllowThreads(__tstate);
33819 if (PyErr_Occurred()) SWIG_fail;
33820 }
33821 {
33822 resultobj = wxPyMake_wxObject(result, 0);
33823 }
33824 return resultobj;
33825 fail:
33826 return NULL;
33827 }
33828
33829
33830 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
33831 PyObject *resultobj;
33832 wxMenu *arg1 = (wxMenu *) 0 ;
33833 long result;
33834 PyObject * obj0 = 0 ;
33835 char *kwnames[] = {
33836 (char *) "self", NULL
33837 };
33838
33839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
33840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33841 if (SWIG_arg_fail(1)) SWIG_fail;
33842 {
33843 PyThreadState* __tstate = wxPyBeginAllowThreads();
33844 result = (long)((wxMenu const *)arg1)->GetStyle();
33845
33846 wxPyEndAllowThreads(__tstate);
33847 if (PyErr_Occurred()) SWIG_fail;
33848 }
33849 {
33850 resultobj = SWIG_From_long((long)(result));
33851 }
33852 return resultobj;
33853 fail:
33854 return NULL;
33855 }
33856
33857
33858 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
33859 PyObject *resultobj;
33860 wxMenu *arg1 = (wxMenu *) 0 ;
33861 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
33862 PyObject * obj0 = 0 ;
33863 PyObject * obj1 = 0 ;
33864 char *kwnames[] = {
33865 (char *) "self",(char *) "source", NULL
33866 };
33867
33868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
33869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33870 if (SWIG_arg_fail(1)) SWIG_fail;
33871 if (obj1) {
33872 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
33873 if (SWIG_arg_fail(2)) SWIG_fail;
33874 }
33875 {
33876 PyThreadState* __tstate = wxPyBeginAllowThreads();
33877 (arg1)->UpdateUI(arg2);
33878
33879 wxPyEndAllowThreads(__tstate);
33880 if (PyErr_Occurred()) SWIG_fail;
33881 }
33882 Py_INCREF(Py_None); resultobj = Py_None;
33883 return resultobj;
33884 fail:
33885 return NULL;
33886 }
33887
33888
33889 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
33890 PyObject *resultobj;
33891 wxMenu *arg1 = (wxMenu *) 0 ;
33892 wxMenuBar *result;
33893 PyObject * obj0 = 0 ;
33894 char *kwnames[] = {
33895 (char *) "self", NULL
33896 };
33897
33898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
33899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33900 if (SWIG_arg_fail(1)) SWIG_fail;
33901 {
33902 PyThreadState* __tstate = wxPyBeginAllowThreads();
33903 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
33904
33905 wxPyEndAllowThreads(__tstate);
33906 if (PyErr_Occurred()) SWIG_fail;
33907 }
33908 {
33909 resultobj = wxPyMake_wxObject(result, 0);
33910 }
33911 return resultobj;
33912 fail:
33913 return NULL;
33914 }
33915
33916
33917 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
33918 PyObject *resultobj;
33919 wxMenu *arg1 = (wxMenu *) 0 ;
33920 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
33921 PyObject * obj0 = 0 ;
33922 PyObject * obj1 = 0 ;
33923 char *kwnames[] = {
33924 (char *) "self",(char *) "menubar", NULL
33925 };
33926
33927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
33928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33929 if (SWIG_arg_fail(1)) SWIG_fail;
33930 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
33931 if (SWIG_arg_fail(2)) SWIG_fail;
33932 {
33933 PyThreadState* __tstate = wxPyBeginAllowThreads();
33934 (arg1)->Attach(arg2);
33935
33936 wxPyEndAllowThreads(__tstate);
33937 if (PyErr_Occurred()) SWIG_fail;
33938 }
33939 Py_INCREF(Py_None); resultobj = Py_None;
33940 return resultobj;
33941 fail:
33942 return NULL;
33943 }
33944
33945
33946 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
33947 PyObject *resultobj;
33948 wxMenu *arg1 = (wxMenu *) 0 ;
33949 PyObject * obj0 = 0 ;
33950 char *kwnames[] = {
33951 (char *) "self", NULL
33952 };
33953
33954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
33955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33956 if (SWIG_arg_fail(1)) SWIG_fail;
33957 {
33958 PyThreadState* __tstate = wxPyBeginAllowThreads();
33959 (arg1)->Detach();
33960
33961 wxPyEndAllowThreads(__tstate);
33962 if (PyErr_Occurred()) SWIG_fail;
33963 }
33964 Py_INCREF(Py_None); resultobj = Py_None;
33965 return resultobj;
33966 fail:
33967 return NULL;
33968 }
33969
33970
33971 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
33972 PyObject *resultobj;
33973 wxMenu *arg1 = (wxMenu *) 0 ;
33974 bool result;
33975 PyObject * obj0 = 0 ;
33976 char *kwnames[] = {
33977 (char *) "self", NULL
33978 };
33979
33980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
33981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33982 if (SWIG_arg_fail(1)) SWIG_fail;
33983 {
33984 PyThreadState* __tstate = wxPyBeginAllowThreads();
33985 result = (bool)((wxMenu const *)arg1)->IsAttached();
33986
33987 wxPyEndAllowThreads(__tstate);
33988 if (PyErr_Occurred()) SWIG_fail;
33989 }
33990 {
33991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33992 }
33993 return resultobj;
33994 fail:
33995 return NULL;
33996 }
33997
33998
33999 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34000 PyObject *resultobj;
34001 wxMenu *arg1 = (wxMenu *) 0 ;
34002 wxMenu *arg2 = (wxMenu *) 0 ;
34003 PyObject * obj0 = 0 ;
34004 PyObject * obj1 = 0 ;
34005 char *kwnames[] = {
34006 (char *) "self",(char *) "parent", NULL
34007 };
34008
34009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34011 if (SWIG_arg_fail(1)) SWIG_fail;
34012 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34013 if (SWIG_arg_fail(2)) SWIG_fail;
34014 {
34015 PyThreadState* __tstate = wxPyBeginAllowThreads();
34016 (arg1)->SetParent(arg2);
34017
34018 wxPyEndAllowThreads(__tstate);
34019 if (PyErr_Occurred()) SWIG_fail;
34020 }
34021 Py_INCREF(Py_None); resultobj = Py_None;
34022 return resultobj;
34023 fail:
34024 return NULL;
34025 }
34026
34027
34028 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34029 PyObject *resultobj;
34030 wxMenu *arg1 = (wxMenu *) 0 ;
34031 wxMenu *result;
34032 PyObject * obj0 = 0 ;
34033 char *kwnames[] = {
34034 (char *) "self", NULL
34035 };
34036
34037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34039 if (SWIG_arg_fail(1)) SWIG_fail;
34040 {
34041 PyThreadState* __tstate = wxPyBeginAllowThreads();
34042 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34043
34044 wxPyEndAllowThreads(__tstate);
34045 if (PyErr_Occurred()) SWIG_fail;
34046 }
34047 {
34048 resultobj = wxPyMake_wxObject(result, 0);
34049 }
34050 return resultobj;
34051 fail:
34052 return NULL;
34053 }
34054
34055
34056 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34057 PyObject *obj;
34058 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34059 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34060 Py_INCREF(obj);
34061 return Py_BuildValue((char *)"");
34062 }
34063 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34064 PyObject *resultobj;
34065 long arg1 = (long) 0 ;
34066 wxMenuBar *result;
34067 PyObject * obj0 = 0 ;
34068 char *kwnames[] = {
34069 (char *) "style", NULL
34070 };
34071
34072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34073 if (obj0) {
34074 {
34075 arg1 = (long)(SWIG_As_long(obj0));
34076 if (SWIG_arg_fail(1)) SWIG_fail;
34077 }
34078 }
34079 {
34080 if (!wxPyCheckForApp()) SWIG_fail;
34081 PyThreadState* __tstate = wxPyBeginAllowThreads();
34082 result = (wxMenuBar *)new wxMenuBar(arg1);
34083
34084 wxPyEndAllowThreads(__tstate);
34085 if (PyErr_Occurred()) SWIG_fail;
34086 }
34087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34088 return resultobj;
34089 fail:
34090 return NULL;
34091 }
34092
34093
34094 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34095 PyObject *resultobj;
34096 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34097 wxMenu *arg2 = (wxMenu *) 0 ;
34098 wxString *arg3 = 0 ;
34099 bool result;
34100 bool temp3 = false ;
34101 PyObject * obj0 = 0 ;
34102 PyObject * obj1 = 0 ;
34103 PyObject * obj2 = 0 ;
34104 char *kwnames[] = {
34105 (char *) "self",(char *) "menu",(char *) "title", NULL
34106 };
34107
34108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34110 if (SWIG_arg_fail(1)) SWIG_fail;
34111 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34112 if (SWIG_arg_fail(2)) SWIG_fail;
34113 {
34114 arg3 = wxString_in_helper(obj2);
34115 if (arg3 == NULL) SWIG_fail;
34116 temp3 = true;
34117 }
34118 {
34119 PyThreadState* __tstate = wxPyBeginAllowThreads();
34120 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34121
34122 wxPyEndAllowThreads(__tstate);
34123 if (PyErr_Occurred()) SWIG_fail;
34124 }
34125 {
34126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34127 }
34128 {
34129 if (temp3)
34130 delete arg3;
34131 }
34132 return resultobj;
34133 fail:
34134 {
34135 if (temp3)
34136 delete arg3;
34137 }
34138 return NULL;
34139 }
34140
34141
34142 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34143 PyObject *resultobj;
34144 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34145 size_t arg2 ;
34146 wxMenu *arg3 = (wxMenu *) 0 ;
34147 wxString *arg4 = 0 ;
34148 bool result;
34149 bool temp4 = false ;
34150 PyObject * obj0 = 0 ;
34151 PyObject * obj1 = 0 ;
34152 PyObject * obj2 = 0 ;
34153 PyObject * obj3 = 0 ;
34154 char *kwnames[] = {
34155 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34156 };
34157
34158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34160 if (SWIG_arg_fail(1)) SWIG_fail;
34161 {
34162 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34163 if (SWIG_arg_fail(2)) SWIG_fail;
34164 }
34165 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34166 if (SWIG_arg_fail(3)) SWIG_fail;
34167 {
34168 arg4 = wxString_in_helper(obj3);
34169 if (arg4 == NULL) SWIG_fail;
34170 temp4 = true;
34171 }
34172 {
34173 PyThreadState* __tstate = wxPyBeginAllowThreads();
34174 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34175
34176 wxPyEndAllowThreads(__tstate);
34177 if (PyErr_Occurred()) SWIG_fail;
34178 }
34179 {
34180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34181 }
34182 {
34183 if (temp4)
34184 delete arg4;
34185 }
34186 return resultobj;
34187 fail:
34188 {
34189 if (temp4)
34190 delete arg4;
34191 }
34192 return NULL;
34193 }
34194
34195
34196 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34197 PyObject *resultobj;
34198 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34199 size_t result;
34200 PyObject * obj0 = 0 ;
34201 char *kwnames[] = {
34202 (char *) "self", NULL
34203 };
34204
34205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34207 if (SWIG_arg_fail(1)) SWIG_fail;
34208 {
34209 PyThreadState* __tstate = wxPyBeginAllowThreads();
34210 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34211
34212 wxPyEndAllowThreads(__tstate);
34213 if (PyErr_Occurred()) SWIG_fail;
34214 }
34215 {
34216 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34217 }
34218 return resultobj;
34219 fail:
34220 return NULL;
34221 }
34222
34223
34224 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34225 PyObject *resultobj;
34226 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34227 size_t arg2 ;
34228 wxMenu *result;
34229 PyObject * obj0 = 0 ;
34230 PyObject * obj1 = 0 ;
34231 char *kwnames[] = {
34232 (char *) "self",(char *) "pos", NULL
34233 };
34234
34235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34237 if (SWIG_arg_fail(1)) SWIG_fail;
34238 {
34239 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34240 if (SWIG_arg_fail(2)) SWIG_fail;
34241 }
34242 {
34243 PyThreadState* __tstate = wxPyBeginAllowThreads();
34244 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34245
34246 wxPyEndAllowThreads(__tstate);
34247 if (PyErr_Occurred()) SWIG_fail;
34248 }
34249 {
34250 resultobj = wxPyMake_wxObject(result, 0);
34251 }
34252 return resultobj;
34253 fail:
34254 return NULL;
34255 }
34256
34257
34258 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34259 PyObject *resultobj;
34260 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34261 size_t arg2 ;
34262 wxMenu *arg3 = (wxMenu *) 0 ;
34263 wxString *arg4 = 0 ;
34264 wxMenu *result;
34265 bool temp4 = false ;
34266 PyObject * obj0 = 0 ;
34267 PyObject * obj1 = 0 ;
34268 PyObject * obj2 = 0 ;
34269 PyObject * obj3 = 0 ;
34270 char *kwnames[] = {
34271 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34272 };
34273
34274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34276 if (SWIG_arg_fail(1)) SWIG_fail;
34277 {
34278 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34279 if (SWIG_arg_fail(2)) SWIG_fail;
34280 }
34281 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34282 if (SWIG_arg_fail(3)) SWIG_fail;
34283 {
34284 arg4 = wxString_in_helper(obj3);
34285 if (arg4 == NULL) SWIG_fail;
34286 temp4 = true;
34287 }
34288 {
34289 PyThreadState* __tstate = wxPyBeginAllowThreads();
34290 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34291
34292 wxPyEndAllowThreads(__tstate);
34293 if (PyErr_Occurred()) SWIG_fail;
34294 }
34295 {
34296 resultobj = wxPyMake_wxObject(result, 0);
34297 }
34298 {
34299 if (temp4)
34300 delete arg4;
34301 }
34302 return resultobj;
34303 fail:
34304 {
34305 if (temp4)
34306 delete arg4;
34307 }
34308 return NULL;
34309 }
34310
34311
34312 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34313 PyObject *resultobj;
34314 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34315 size_t arg2 ;
34316 wxMenu *result;
34317 PyObject * obj0 = 0 ;
34318 PyObject * obj1 = 0 ;
34319 char *kwnames[] = {
34320 (char *) "self",(char *) "pos", NULL
34321 };
34322
34323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34325 if (SWIG_arg_fail(1)) SWIG_fail;
34326 {
34327 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34328 if (SWIG_arg_fail(2)) SWIG_fail;
34329 }
34330 {
34331 PyThreadState* __tstate = wxPyBeginAllowThreads();
34332 result = (wxMenu *)(arg1)->Remove(arg2);
34333
34334 wxPyEndAllowThreads(__tstate);
34335 if (PyErr_Occurred()) SWIG_fail;
34336 }
34337 {
34338 resultobj = wxPyMake_wxObject(result, 0);
34339 }
34340 return resultobj;
34341 fail:
34342 return NULL;
34343 }
34344
34345
34346 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34347 PyObject *resultobj;
34348 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34349 size_t arg2 ;
34350 bool arg3 ;
34351 PyObject * obj0 = 0 ;
34352 PyObject * obj1 = 0 ;
34353 PyObject * obj2 = 0 ;
34354 char *kwnames[] = {
34355 (char *) "self",(char *) "pos",(char *) "enable", NULL
34356 };
34357
34358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34360 if (SWIG_arg_fail(1)) SWIG_fail;
34361 {
34362 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34363 if (SWIG_arg_fail(2)) SWIG_fail;
34364 }
34365 {
34366 arg3 = (bool)(SWIG_As_bool(obj2));
34367 if (SWIG_arg_fail(3)) SWIG_fail;
34368 }
34369 {
34370 PyThreadState* __tstate = wxPyBeginAllowThreads();
34371 (arg1)->EnableTop(arg2,arg3);
34372
34373 wxPyEndAllowThreads(__tstate);
34374 if (PyErr_Occurred()) SWIG_fail;
34375 }
34376 Py_INCREF(Py_None); resultobj = Py_None;
34377 return resultobj;
34378 fail:
34379 return NULL;
34380 }
34381
34382
34383 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
34384 PyObject *resultobj;
34385 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34386 size_t arg2 ;
34387 bool result;
34388 PyObject * obj0 = 0 ;
34389 PyObject * obj1 = 0 ;
34390 char *kwnames[] = {
34391 (char *) "self",(char *) "pos", NULL
34392 };
34393
34394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
34395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34396 if (SWIG_arg_fail(1)) SWIG_fail;
34397 {
34398 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34399 if (SWIG_arg_fail(2)) SWIG_fail;
34400 }
34401 {
34402 PyThreadState* __tstate = wxPyBeginAllowThreads();
34403 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
34404
34405 wxPyEndAllowThreads(__tstate);
34406 if (PyErr_Occurred()) SWIG_fail;
34407 }
34408 {
34409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34410 }
34411 return resultobj;
34412 fail:
34413 return NULL;
34414 }
34415
34416
34417 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34418 PyObject *resultobj;
34419 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34420 size_t arg2 ;
34421 wxString *arg3 = 0 ;
34422 bool temp3 = false ;
34423 PyObject * obj0 = 0 ;
34424 PyObject * obj1 = 0 ;
34425 PyObject * obj2 = 0 ;
34426 char *kwnames[] = {
34427 (char *) "self",(char *) "pos",(char *) "label", NULL
34428 };
34429
34430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34432 if (SWIG_arg_fail(1)) SWIG_fail;
34433 {
34434 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34435 if (SWIG_arg_fail(2)) SWIG_fail;
34436 }
34437 {
34438 arg3 = wxString_in_helper(obj2);
34439 if (arg3 == NULL) SWIG_fail;
34440 temp3 = true;
34441 }
34442 {
34443 PyThreadState* __tstate = wxPyBeginAllowThreads();
34444 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
34445
34446 wxPyEndAllowThreads(__tstate);
34447 if (PyErr_Occurred()) SWIG_fail;
34448 }
34449 Py_INCREF(Py_None); resultobj = Py_None;
34450 {
34451 if (temp3)
34452 delete arg3;
34453 }
34454 return resultobj;
34455 fail:
34456 {
34457 if (temp3)
34458 delete arg3;
34459 }
34460 return NULL;
34461 }
34462
34463
34464 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34465 PyObject *resultobj;
34466 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34467 size_t arg2 ;
34468 wxString result;
34469 PyObject * obj0 = 0 ;
34470 PyObject * obj1 = 0 ;
34471 char *kwnames[] = {
34472 (char *) "self",(char *) "pos", NULL
34473 };
34474
34475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
34476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34477 if (SWIG_arg_fail(1)) SWIG_fail;
34478 {
34479 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34480 if (SWIG_arg_fail(2)) SWIG_fail;
34481 }
34482 {
34483 PyThreadState* __tstate = wxPyBeginAllowThreads();
34484 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
34485
34486 wxPyEndAllowThreads(__tstate);
34487 if (PyErr_Occurred()) SWIG_fail;
34488 }
34489 {
34490 #if wxUSE_UNICODE
34491 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34492 #else
34493 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34494 #endif
34495 }
34496 return resultobj;
34497 fail:
34498 return NULL;
34499 }
34500
34501
34502 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34503 PyObject *resultobj;
34504 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34505 wxString *arg2 = 0 ;
34506 wxString *arg3 = 0 ;
34507 int result;
34508 bool temp2 = false ;
34509 bool temp3 = false ;
34510 PyObject * obj0 = 0 ;
34511 PyObject * obj1 = 0 ;
34512 PyObject * obj2 = 0 ;
34513 char *kwnames[] = {
34514 (char *) "self",(char *) "menu",(char *) "item", NULL
34515 };
34516
34517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
34518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34519 if (SWIG_arg_fail(1)) SWIG_fail;
34520 {
34521 arg2 = wxString_in_helper(obj1);
34522 if (arg2 == NULL) SWIG_fail;
34523 temp2 = true;
34524 }
34525 {
34526 arg3 = wxString_in_helper(obj2);
34527 if (arg3 == NULL) SWIG_fail;
34528 temp3 = true;
34529 }
34530 {
34531 PyThreadState* __tstate = wxPyBeginAllowThreads();
34532 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
34533
34534 wxPyEndAllowThreads(__tstate);
34535 if (PyErr_Occurred()) SWIG_fail;
34536 }
34537 {
34538 resultobj = SWIG_From_int((int)(result));
34539 }
34540 {
34541 if (temp2)
34542 delete arg2;
34543 }
34544 {
34545 if (temp3)
34546 delete arg3;
34547 }
34548 return resultobj;
34549 fail:
34550 {
34551 if (temp2)
34552 delete arg2;
34553 }
34554 {
34555 if (temp3)
34556 delete arg3;
34557 }
34558 return NULL;
34559 }
34560
34561
34562 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34563 PyObject *resultobj;
34564 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34565 int arg2 ;
34566 wxMenuItem *result;
34567 PyObject * obj0 = 0 ;
34568 PyObject * obj1 = 0 ;
34569 char *kwnames[] = {
34570 (char *) "self",(char *) "id", NULL
34571 };
34572
34573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34575 if (SWIG_arg_fail(1)) SWIG_fail;
34576 {
34577 arg2 = (int)(SWIG_As_int(obj1));
34578 if (SWIG_arg_fail(2)) SWIG_fail;
34579 }
34580 {
34581 PyThreadState* __tstate = wxPyBeginAllowThreads();
34582 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
34583
34584 wxPyEndAllowThreads(__tstate);
34585 if (PyErr_Occurred()) SWIG_fail;
34586 }
34587 {
34588 resultobj = wxPyMake_wxObject(result, 0);
34589 }
34590 return resultobj;
34591 fail:
34592 return NULL;
34593 }
34594
34595
34596 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34597 PyObject *resultobj;
34598 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34599 wxString *arg2 = 0 ;
34600 int result;
34601 bool temp2 = false ;
34602 PyObject * obj0 = 0 ;
34603 PyObject * obj1 = 0 ;
34604 char *kwnames[] = {
34605 (char *) "self",(char *) "title", NULL
34606 };
34607
34608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
34609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34610 if (SWIG_arg_fail(1)) SWIG_fail;
34611 {
34612 arg2 = wxString_in_helper(obj1);
34613 if (arg2 == NULL) SWIG_fail;
34614 temp2 = true;
34615 }
34616 {
34617 PyThreadState* __tstate = wxPyBeginAllowThreads();
34618 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
34619
34620 wxPyEndAllowThreads(__tstate);
34621 if (PyErr_Occurred()) SWIG_fail;
34622 }
34623 {
34624 resultobj = SWIG_From_int((int)(result));
34625 }
34626 {
34627 if (temp2)
34628 delete arg2;
34629 }
34630 return resultobj;
34631 fail:
34632 {
34633 if (temp2)
34634 delete arg2;
34635 }
34636 return NULL;
34637 }
34638
34639
34640 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34641 PyObject *resultobj;
34642 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34643 int arg2 ;
34644 bool arg3 ;
34645 PyObject * obj0 = 0 ;
34646 PyObject * obj1 = 0 ;
34647 PyObject * obj2 = 0 ;
34648 char *kwnames[] = {
34649 (char *) "self",(char *) "id",(char *) "enable", NULL
34650 };
34651
34652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34654 if (SWIG_arg_fail(1)) SWIG_fail;
34655 {
34656 arg2 = (int)(SWIG_As_int(obj1));
34657 if (SWIG_arg_fail(2)) SWIG_fail;
34658 }
34659 {
34660 arg3 = (bool)(SWIG_As_bool(obj2));
34661 if (SWIG_arg_fail(3)) SWIG_fail;
34662 }
34663 {
34664 PyThreadState* __tstate = wxPyBeginAllowThreads();
34665 (arg1)->Enable(arg2,arg3);
34666
34667 wxPyEndAllowThreads(__tstate);
34668 if (PyErr_Occurred()) SWIG_fail;
34669 }
34670 Py_INCREF(Py_None); resultobj = Py_None;
34671 return resultobj;
34672 fail:
34673 return NULL;
34674 }
34675
34676
34677 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34678 PyObject *resultobj;
34679 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34680 int arg2 ;
34681 bool arg3 ;
34682 PyObject * obj0 = 0 ;
34683 PyObject * obj1 = 0 ;
34684 PyObject * obj2 = 0 ;
34685 char *kwnames[] = {
34686 (char *) "self",(char *) "id",(char *) "check", NULL
34687 };
34688
34689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34691 if (SWIG_arg_fail(1)) SWIG_fail;
34692 {
34693 arg2 = (int)(SWIG_As_int(obj1));
34694 if (SWIG_arg_fail(2)) SWIG_fail;
34695 }
34696 {
34697 arg3 = (bool)(SWIG_As_bool(obj2));
34698 if (SWIG_arg_fail(3)) SWIG_fail;
34699 }
34700 {
34701 PyThreadState* __tstate = wxPyBeginAllowThreads();
34702 (arg1)->Check(arg2,arg3);
34703
34704 wxPyEndAllowThreads(__tstate);
34705 if (PyErr_Occurred()) SWIG_fail;
34706 }
34707 Py_INCREF(Py_None); resultobj = Py_None;
34708 return resultobj;
34709 fail:
34710 return NULL;
34711 }
34712
34713
34714 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34715 PyObject *resultobj;
34716 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34717 int arg2 ;
34718 bool result;
34719 PyObject * obj0 = 0 ;
34720 PyObject * obj1 = 0 ;
34721 char *kwnames[] = {
34722 (char *) "self",(char *) "id", NULL
34723 };
34724
34725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34727 if (SWIG_arg_fail(1)) SWIG_fail;
34728 {
34729 arg2 = (int)(SWIG_As_int(obj1));
34730 if (SWIG_arg_fail(2)) SWIG_fail;
34731 }
34732 {
34733 PyThreadState* __tstate = wxPyBeginAllowThreads();
34734 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
34735
34736 wxPyEndAllowThreads(__tstate);
34737 if (PyErr_Occurred()) SWIG_fail;
34738 }
34739 {
34740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34741 }
34742 return resultobj;
34743 fail:
34744 return NULL;
34745 }
34746
34747
34748 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34749 PyObject *resultobj;
34750 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34751 int arg2 ;
34752 bool result;
34753 PyObject * obj0 = 0 ;
34754 PyObject * obj1 = 0 ;
34755 char *kwnames[] = {
34756 (char *) "self",(char *) "id", NULL
34757 };
34758
34759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34761 if (SWIG_arg_fail(1)) SWIG_fail;
34762 {
34763 arg2 = (int)(SWIG_As_int(obj1));
34764 if (SWIG_arg_fail(2)) SWIG_fail;
34765 }
34766 {
34767 PyThreadState* __tstate = wxPyBeginAllowThreads();
34768 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
34769
34770 wxPyEndAllowThreads(__tstate);
34771 if (PyErr_Occurred()) SWIG_fail;
34772 }
34773 {
34774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34775 }
34776 return resultobj;
34777 fail:
34778 return NULL;
34779 }
34780
34781
34782 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34783 PyObject *resultobj;
34784 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34785 int arg2 ;
34786 wxString *arg3 = 0 ;
34787 bool temp3 = false ;
34788 PyObject * obj0 = 0 ;
34789 PyObject * obj1 = 0 ;
34790 PyObject * obj2 = 0 ;
34791 char *kwnames[] = {
34792 (char *) "self",(char *) "id",(char *) "label", NULL
34793 };
34794
34795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34797 if (SWIG_arg_fail(1)) SWIG_fail;
34798 {
34799 arg2 = (int)(SWIG_As_int(obj1));
34800 if (SWIG_arg_fail(2)) SWIG_fail;
34801 }
34802 {
34803 arg3 = wxString_in_helper(obj2);
34804 if (arg3 == NULL) SWIG_fail;
34805 temp3 = true;
34806 }
34807 {
34808 PyThreadState* __tstate = wxPyBeginAllowThreads();
34809 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34810
34811 wxPyEndAllowThreads(__tstate);
34812 if (PyErr_Occurred()) SWIG_fail;
34813 }
34814 Py_INCREF(Py_None); resultobj = Py_None;
34815 {
34816 if (temp3)
34817 delete arg3;
34818 }
34819 return resultobj;
34820 fail:
34821 {
34822 if (temp3)
34823 delete arg3;
34824 }
34825 return NULL;
34826 }
34827
34828
34829 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34830 PyObject *resultobj;
34831 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34832 int arg2 ;
34833 wxString result;
34834 PyObject * obj0 = 0 ;
34835 PyObject * obj1 = 0 ;
34836 char *kwnames[] = {
34837 (char *) "self",(char *) "id", NULL
34838 };
34839
34840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34842 if (SWIG_arg_fail(1)) SWIG_fail;
34843 {
34844 arg2 = (int)(SWIG_As_int(obj1));
34845 if (SWIG_arg_fail(2)) SWIG_fail;
34846 }
34847 {
34848 PyThreadState* __tstate = wxPyBeginAllowThreads();
34849 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
34850
34851 wxPyEndAllowThreads(__tstate);
34852 if (PyErr_Occurred()) SWIG_fail;
34853 }
34854 {
34855 #if wxUSE_UNICODE
34856 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34857 #else
34858 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34859 #endif
34860 }
34861 return resultobj;
34862 fail:
34863 return NULL;
34864 }
34865
34866
34867 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34868 PyObject *resultobj;
34869 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34870 int arg2 ;
34871 wxString *arg3 = 0 ;
34872 bool temp3 = false ;
34873 PyObject * obj0 = 0 ;
34874 PyObject * obj1 = 0 ;
34875 PyObject * obj2 = 0 ;
34876 char *kwnames[] = {
34877 (char *) "self",(char *) "id",(char *) "helpString", NULL
34878 };
34879
34880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34882 if (SWIG_arg_fail(1)) SWIG_fail;
34883 {
34884 arg2 = (int)(SWIG_As_int(obj1));
34885 if (SWIG_arg_fail(2)) SWIG_fail;
34886 }
34887 {
34888 arg3 = wxString_in_helper(obj2);
34889 if (arg3 == NULL) SWIG_fail;
34890 temp3 = true;
34891 }
34892 {
34893 PyThreadState* __tstate = wxPyBeginAllowThreads();
34894 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34895
34896 wxPyEndAllowThreads(__tstate);
34897 if (PyErr_Occurred()) SWIG_fail;
34898 }
34899 Py_INCREF(Py_None); resultobj = Py_None;
34900 {
34901 if (temp3)
34902 delete arg3;
34903 }
34904 return resultobj;
34905 fail:
34906 {
34907 if (temp3)
34908 delete arg3;
34909 }
34910 return NULL;
34911 }
34912
34913
34914 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34915 PyObject *resultobj;
34916 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34917 int arg2 ;
34918 wxString result;
34919 PyObject * obj0 = 0 ;
34920 PyObject * obj1 = 0 ;
34921 char *kwnames[] = {
34922 (char *) "self",(char *) "id", NULL
34923 };
34924
34925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34927 if (SWIG_arg_fail(1)) SWIG_fail;
34928 {
34929 arg2 = (int)(SWIG_As_int(obj1));
34930 if (SWIG_arg_fail(2)) SWIG_fail;
34931 }
34932 {
34933 PyThreadState* __tstate = wxPyBeginAllowThreads();
34934 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
34935
34936 wxPyEndAllowThreads(__tstate);
34937 if (PyErr_Occurred()) SWIG_fail;
34938 }
34939 {
34940 #if wxUSE_UNICODE
34941 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34942 #else
34943 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34944 #endif
34945 }
34946 return resultobj;
34947 fail:
34948 return NULL;
34949 }
34950
34951
34952 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
34953 PyObject *resultobj;
34954 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34955 wxFrame *result;
34956 PyObject * obj0 = 0 ;
34957 char *kwnames[] = {
34958 (char *) "self", NULL
34959 };
34960
34961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
34962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34963 if (SWIG_arg_fail(1)) SWIG_fail;
34964 {
34965 PyThreadState* __tstate = wxPyBeginAllowThreads();
34966 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
34967
34968 wxPyEndAllowThreads(__tstate);
34969 if (PyErr_Occurred()) SWIG_fail;
34970 }
34971 {
34972 resultobj = wxPyMake_wxObject(result, 0);
34973 }
34974 return resultobj;
34975 fail:
34976 return NULL;
34977 }
34978
34979
34980 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34981 PyObject *resultobj;
34982 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34983 bool result;
34984 PyObject * obj0 = 0 ;
34985 char *kwnames[] = {
34986 (char *) "self", NULL
34987 };
34988
34989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
34990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34991 if (SWIG_arg_fail(1)) SWIG_fail;
34992 {
34993 PyThreadState* __tstate = wxPyBeginAllowThreads();
34994 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
34995
34996 wxPyEndAllowThreads(__tstate);
34997 if (PyErr_Occurred()) SWIG_fail;
34998 }
34999 {
35000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35001 }
35002 return resultobj;
35003 fail:
35004 return NULL;
35005 }
35006
35007
35008 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35009 PyObject *resultobj;
35010 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35011 wxFrame *arg2 = (wxFrame *) 0 ;
35012 PyObject * obj0 = 0 ;
35013 PyObject * obj1 = 0 ;
35014 char *kwnames[] = {
35015 (char *) "self",(char *) "frame", NULL
35016 };
35017
35018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35020 if (SWIG_arg_fail(1)) SWIG_fail;
35021 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35022 if (SWIG_arg_fail(2)) SWIG_fail;
35023 {
35024 PyThreadState* __tstate = wxPyBeginAllowThreads();
35025 (arg1)->Attach(arg2);
35026
35027 wxPyEndAllowThreads(__tstate);
35028 if (PyErr_Occurred()) SWIG_fail;
35029 }
35030 Py_INCREF(Py_None); resultobj = Py_None;
35031 return resultobj;
35032 fail:
35033 return NULL;
35034 }
35035
35036
35037 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35038 PyObject *resultobj;
35039 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35040 PyObject * obj0 = 0 ;
35041 char *kwnames[] = {
35042 (char *) "self", NULL
35043 };
35044
35045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35047 if (SWIG_arg_fail(1)) SWIG_fail;
35048 {
35049 PyThreadState* __tstate = wxPyBeginAllowThreads();
35050 (arg1)->Detach();
35051
35052 wxPyEndAllowThreads(__tstate);
35053 if (PyErr_Occurred()) SWIG_fail;
35054 }
35055 Py_INCREF(Py_None); resultobj = Py_None;
35056 return resultobj;
35057 fail:
35058 return NULL;
35059 }
35060
35061
35062 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35063 PyObject *obj;
35064 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35065 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35066 Py_INCREF(obj);
35067 return Py_BuildValue((char *)"");
35068 }
35069 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35070 PyObject *resultobj;
35071 wxMenu *arg1 = (wxMenu *) NULL ;
35072 int arg2 = (int) wxID_ANY ;
35073 wxString const &arg3_defvalue = wxPyEmptyString ;
35074 wxString *arg3 = (wxString *) &arg3_defvalue ;
35075 wxString const &arg4_defvalue = wxPyEmptyString ;
35076 wxString *arg4 = (wxString *) &arg4_defvalue ;
35077 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35078 wxMenu *arg6 = (wxMenu *) NULL ;
35079 wxMenuItem *result;
35080 bool temp3 = false ;
35081 bool temp4 = false ;
35082 PyObject * obj0 = 0 ;
35083 PyObject * obj1 = 0 ;
35084 PyObject * obj2 = 0 ;
35085 PyObject * obj3 = 0 ;
35086 PyObject * obj4 = 0 ;
35087 PyObject * obj5 = 0 ;
35088 char *kwnames[] = {
35089 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35090 };
35091
35092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35093 if (obj0) {
35094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35095 if (SWIG_arg_fail(1)) SWIG_fail;
35096 }
35097 if (obj1) {
35098 {
35099 arg2 = (int)(SWIG_As_int(obj1));
35100 if (SWIG_arg_fail(2)) SWIG_fail;
35101 }
35102 }
35103 if (obj2) {
35104 {
35105 arg3 = wxString_in_helper(obj2);
35106 if (arg3 == NULL) SWIG_fail;
35107 temp3 = true;
35108 }
35109 }
35110 if (obj3) {
35111 {
35112 arg4 = wxString_in_helper(obj3);
35113 if (arg4 == NULL) SWIG_fail;
35114 temp4 = true;
35115 }
35116 }
35117 if (obj4) {
35118 {
35119 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35120 if (SWIG_arg_fail(5)) SWIG_fail;
35121 }
35122 }
35123 if (obj5) {
35124 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35125 if (SWIG_arg_fail(6)) SWIG_fail;
35126 }
35127 {
35128 PyThreadState* __tstate = wxPyBeginAllowThreads();
35129 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35130
35131 wxPyEndAllowThreads(__tstate);
35132 if (PyErr_Occurred()) SWIG_fail;
35133 }
35134 {
35135 resultobj = wxPyMake_wxObject(result, 1);
35136 }
35137 {
35138 if (temp3)
35139 delete arg3;
35140 }
35141 {
35142 if (temp4)
35143 delete arg4;
35144 }
35145 return resultobj;
35146 fail:
35147 {
35148 if (temp3)
35149 delete arg3;
35150 }
35151 {
35152 if (temp4)
35153 delete arg4;
35154 }
35155 return NULL;
35156 }
35157
35158
35159 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35160 PyObject *resultobj;
35161 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35162 wxMenu *result;
35163 PyObject * obj0 = 0 ;
35164 char *kwnames[] = {
35165 (char *) "self", NULL
35166 };
35167
35168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35170 if (SWIG_arg_fail(1)) SWIG_fail;
35171 {
35172 PyThreadState* __tstate = wxPyBeginAllowThreads();
35173 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35174
35175 wxPyEndAllowThreads(__tstate);
35176 if (PyErr_Occurred()) SWIG_fail;
35177 }
35178 {
35179 resultobj = wxPyMake_wxObject(result, 0);
35180 }
35181 return resultobj;
35182 fail:
35183 return NULL;
35184 }
35185
35186
35187 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35188 PyObject *resultobj;
35189 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35190 wxMenu *arg2 = (wxMenu *) 0 ;
35191 PyObject * obj0 = 0 ;
35192 PyObject * obj1 = 0 ;
35193 char *kwnames[] = {
35194 (char *) "self",(char *) "menu", NULL
35195 };
35196
35197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35199 if (SWIG_arg_fail(1)) SWIG_fail;
35200 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35201 if (SWIG_arg_fail(2)) SWIG_fail;
35202 {
35203 PyThreadState* __tstate = wxPyBeginAllowThreads();
35204 (arg1)->SetMenu(arg2);
35205
35206 wxPyEndAllowThreads(__tstate);
35207 if (PyErr_Occurred()) SWIG_fail;
35208 }
35209 Py_INCREF(Py_None); resultobj = Py_None;
35210 return resultobj;
35211 fail:
35212 return NULL;
35213 }
35214
35215
35216 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35217 PyObject *resultobj;
35218 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35219 int arg2 ;
35220 PyObject * obj0 = 0 ;
35221 PyObject * obj1 = 0 ;
35222 char *kwnames[] = {
35223 (char *) "self",(char *) "id", NULL
35224 };
35225
35226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35228 if (SWIG_arg_fail(1)) SWIG_fail;
35229 {
35230 arg2 = (int)(SWIG_As_int(obj1));
35231 if (SWIG_arg_fail(2)) SWIG_fail;
35232 }
35233 {
35234 PyThreadState* __tstate = wxPyBeginAllowThreads();
35235 (arg1)->SetId(arg2);
35236
35237 wxPyEndAllowThreads(__tstate);
35238 if (PyErr_Occurred()) SWIG_fail;
35239 }
35240 Py_INCREF(Py_None); resultobj = Py_None;
35241 return resultobj;
35242 fail:
35243 return NULL;
35244 }
35245
35246
35247 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35248 PyObject *resultobj;
35249 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35250 int result;
35251 PyObject * obj0 = 0 ;
35252 char *kwnames[] = {
35253 (char *) "self", NULL
35254 };
35255
35256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35258 if (SWIG_arg_fail(1)) SWIG_fail;
35259 {
35260 PyThreadState* __tstate = wxPyBeginAllowThreads();
35261 result = (int)((wxMenuItem const *)arg1)->GetId();
35262
35263 wxPyEndAllowThreads(__tstate);
35264 if (PyErr_Occurred()) SWIG_fail;
35265 }
35266 {
35267 resultobj = SWIG_From_int((int)(result));
35268 }
35269 return resultobj;
35270 fail:
35271 return NULL;
35272 }
35273
35274
35275 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35276 PyObject *resultobj;
35277 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35278 bool result;
35279 PyObject * obj0 = 0 ;
35280 char *kwnames[] = {
35281 (char *) "self", NULL
35282 };
35283
35284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35286 if (SWIG_arg_fail(1)) SWIG_fail;
35287 {
35288 PyThreadState* __tstate = wxPyBeginAllowThreads();
35289 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35290
35291 wxPyEndAllowThreads(__tstate);
35292 if (PyErr_Occurred()) SWIG_fail;
35293 }
35294 {
35295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35296 }
35297 return resultobj;
35298 fail:
35299 return NULL;
35300 }
35301
35302
35303 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35304 PyObject *resultobj;
35305 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35306 wxString *arg2 = 0 ;
35307 bool temp2 = false ;
35308 PyObject * obj0 = 0 ;
35309 PyObject * obj1 = 0 ;
35310 char *kwnames[] = {
35311 (char *) "self",(char *) "str", NULL
35312 };
35313
35314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35316 if (SWIG_arg_fail(1)) SWIG_fail;
35317 {
35318 arg2 = wxString_in_helper(obj1);
35319 if (arg2 == NULL) SWIG_fail;
35320 temp2 = true;
35321 }
35322 {
35323 PyThreadState* __tstate = wxPyBeginAllowThreads();
35324 (arg1)->SetText((wxString const &)*arg2);
35325
35326 wxPyEndAllowThreads(__tstate);
35327 if (PyErr_Occurred()) SWIG_fail;
35328 }
35329 Py_INCREF(Py_None); resultobj = Py_None;
35330 {
35331 if (temp2)
35332 delete arg2;
35333 }
35334 return resultobj;
35335 fail:
35336 {
35337 if (temp2)
35338 delete arg2;
35339 }
35340 return NULL;
35341 }
35342
35343
35344 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35345 PyObject *resultobj;
35346 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35347 wxString result;
35348 PyObject * obj0 = 0 ;
35349 char *kwnames[] = {
35350 (char *) "self", NULL
35351 };
35352
35353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
35354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35355 if (SWIG_arg_fail(1)) SWIG_fail;
35356 {
35357 PyThreadState* __tstate = wxPyBeginAllowThreads();
35358 result = ((wxMenuItem const *)arg1)->GetLabel();
35359
35360 wxPyEndAllowThreads(__tstate);
35361 if (PyErr_Occurred()) SWIG_fail;
35362 }
35363 {
35364 #if wxUSE_UNICODE
35365 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35366 #else
35367 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35368 #endif
35369 }
35370 return resultobj;
35371 fail:
35372 return NULL;
35373 }
35374
35375
35376 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
35377 PyObject *resultobj;
35378 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35379 wxString *result;
35380 PyObject * obj0 = 0 ;
35381 char *kwnames[] = {
35382 (char *) "self", NULL
35383 };
35384
35385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
35386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35387 if (SWIG_arg_fail(1)) SWIG_fail;
35388 {
35389 PyThreadState* __tstate = wxPyBeginAllowThreads();
35390 {
35391 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
35392 result = (wxString *) &_result_ref;
35393 }
35394
35395 wxPyEndAllowThreads(__tstate);
35396 if (PyErr_Occurred()) SWIG_fail;
35397 }
35398 {
35399 #if wxUSE_UNICODE
35400 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35401 #else
35402 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35403 #endif
35404 }
35405 return resultobj;
35406 fail:
35407 return NULL;
35408 }
35409
35410
35411 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
35412 PyObject *resultobj;
35413 wxString *arg1 = 0 ;
35414 wxString result;
35415 bool temp1 = false ;
35416 PyObject * obj0 = 0 ;
35417 char *kwnames[] = {
35418 (char *) "text", NULL
35419 };
35420
35421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
35422 {
35423 arg1 = wxString_in_helper(obj0);
35424 if (arg1 == NULL) SWIG_fail;
35425 temp1 = true;
35426 }
35427 {
35428 PyThreadState* __tstate = wxPyBeginAllowThreads();
35429 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
35430
35431 wxPyEndAllowThreads(__tstate);
35432 if (PyErr_Occurred()) SWIG_fail;
35433 }
35434 {
35435 #if wxUSE_UNICODE
35436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35437 #else
35438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35439 #endif
35440 }
35441 {
35442 if (temp1)
35443 delete arg1;
35444 }
35445 return resultobj;
35446 fail:
35447 {
35448 if (temp1)
35449 delete arg1;
35450 }
35451 return NULL;
35452 }
35453
35454
35455 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35456 PyObject *resultobj;
35457 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35458 wxItemKind result;
35459 PyObject * obj0 = 0 ;
35460 char *kwnames[] = {
35461 (char *) "self", NULL
35462 };
35463
35464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
35465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35466 if (SWIG_arg_fail(1)) SWIG_fail;
35467 {
35468 PyThreadState* __tstate = wxPyBeginAllowThreads();
35469 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
35470
35471 wxPyEndAllowThreads(__tstate);
35472 if (PyErr_Occurred()) SWIG_fail;
35473 }
35474 resultobj = SWIG_From_int((result));
35475 return resultobj;
35476 fail:
35477 return NULL;
35478 }
35479
35480
35481 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35482 PyObject *resultobj;
35483 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35484 wxItemKind arg2 ;
35485 PyObject * obj0 = 0 ;
35486 PyObject * obj1 = 0 ;
35487 char *kwnames[] = {
35488 (char *) "self",(char *) "kind", NULL
35489 };
35490
35491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
35492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35493 if (SWIG_arg_fail(1)) SWIG_fail;
35494 {
35495 arg2 = (wxItemKind)(SWIG_As_int(obj1));
35496 if (SWIG_arg_fail(2)) SWIG_fail;
35497 }
35498 {
35499 PyThreadState* __tstate = wxPyBeginAllowThreads();
35500 (arg1)->SetKind((wxItemKind )arg2);
35501
35502 wxPyEndAllowThreads(__tstate);
35503 if (PyErr_Occurred()) SWIG_fail;
35504 }
35505 Py_INCREF(Py_None); resultobj = Py_None;
35506 return resultobj;
35507 fail:
35508 return NULL;
35509 }
35510
35511
35512 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35513 PyObject *resultobj;
35514 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35515 bool arg2 ;
35516 PyObject * obj0 = 0 ;
35517 PyObject * obj1 = 0 ;
35518 char *kwnames[] = {
35519 (char *) "self",(char *) "checkable", NULL
35520 };
35521
35522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
35523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35524 if (SWIG_arg_fail(1)) SWIG_fail;
35525 {
35526 arg2 = (bool)(SWIG_As_bool(obj1));
35527 if (SWIG_arg_fail(2)) SWIG_fail;
35528 }
35529 {
35530 PyThreadState* __tstate = wxPyBeginAllowThreads();
35531 (arg1)->SetCheckable(arg2);
35532
35533 wxPyEndAllowThreads(__tstate);
35534 if (PyErr_Occurred()) SWIG_fail;
35535 }
35536 Py_INCREF(Py_None); resultobj = Py_None;
35537 return resultobj;
35538 fail:
35539 return NULL;
35540 }
35541
35542
35543 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35544 PyObject *resultobj;
35545 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35546 bool result;
35547 PyObject * obj0 = 0 ;
35548 char *kwnames[] = {
35549 (char *) "self", NULL
35550 };
35551
35552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
35553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35554 if (SWIG_arg_fail(1)) SWIG_fail;
35555 {
35556 PyThreadState* __tstate = wxPyBeginAllowThreads();
35557 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
35558
35559 wxPyEndAllowThreads(__tstate);
35560 if (PyErr_Occurred()) SWIG_fail;
35561 }
35562 {
35563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35564 }
35565 return resultobj;
35566 fail:
35567 return NULL;
35568 }
35569
35570
35571 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35572 PyObject *resultobj;
35573 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35574 bool result;
35575 PyObject * obj0 = 0 ;
35576 char *kwnames[] = {
35577 (char *) "self", NULL
35578 };
35579
35580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
35581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35582 if (SWIG_arg_fail(1)) SWIG_fail;
35583 {
35584 PyThreadState* __tstate = wxPyBeginAllowThreads();
35585 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
35586
35587 wxPyEndAllowThreads(__tstate);
35588 if (PyErr_Occurred()) SWIG_fail;
35589 }
35590 {
35591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35592 }
35593 return resultobj;
35594 fail:
35595 return NULL;
35596 }
35597
35598
35599 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35600 PyObject *resultobj;
35601 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35602 wxMenu *arg2 = (wxMenu *) 0 ;
35603 PyObject * obj0 = 0 ;
35604 PyObject * obj1 = 0 ;
35605 char *kwnames[] = {
35606 (char *) "self",(char *) "menu", NULL
35607 };
35608
35609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
35610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35611 if (SWIG_arg_fail(1)) SWIG_fail;
35612 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35613 if (SWIG_arg_fail(2)) SWIG_fail;
35614 {
35615 PyThreadState* __tstate = wxPyBeginAllowThreads();
35616 (arg1)->SetSubMenu(arg2);
35617
35618 wxPyEndAllowThreads(__tstate);
35619 if (PyErr_Occurred()) SWIG_fail;
35620 }
35621 Py_INCREF(Py_None); resultobj = Py_None;
35622 return resultobj;
35623 fail:
35624 return NULL;
35625 }
35626
35627
35628 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35629 PyObject *resultobj;
35630 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35631 wxMenu *result;
35632 PyObject * obj0 = 0 ;
35633 char *kwnames[] = {
35634 (char *) "self", NULL
35635 };
35636
35637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
35638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35639 if (SWIG_arg_fail(1)) SWIG_fail;
35640 {
35641 PyThreadState* __tstate = wxPyBeginAllowThreads();
35642 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
35643
35644 wxPyEndAllowThreads(__tstate);
35645 if (PyErr_Occurred()) SWIG_fail;
35646 }
35647 {
35648 resultobj = wxPyMake_wxObject(result, 0);
35649 }
35650 return resultobj;
35651 fail:
35652 return NULL;
35653 }
35654
35655
35656 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35657 PyObject *resultobj;
35658 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35659 bool arg2 = (bool) true ;
35660 PyObject * obj0 = 0 ;
35661 PyObject * obj1 = 0 ;
35662 char *kwnames[] = {
35663 (char *) "self",(char *) "enable", NULL
35664 };
35665
35666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
35667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35668 if (SWIG_arg_fail(1)) SWIG_fail;
35669 if (obj1) {
35670 {
35671 arg2 = (bool)(SWIG_As_bool(obj1));
35672 if (SWIG_arg_fail(2)) SWIG_fail;
35673 }
35674 }
35675 {
35676 PyThreadState* __tstate = wxPyBeginAllowThreads();
35677 (arg1)->Enable(arg2);
35678
35679 wxPyEndAllowThreads(__tstate);
35680 if (PyErr_Occurred()) SWIG_fail;
35681 }
35682 Py_INCREF(Py_None); resultobj = Py_None;
35683 return resultobj;
35684 fail:
35685 return NULL;
35686 }
35687
35688
35689 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35690 PyObject *resultobj;
35691 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35692 bool result;
35693 PyObject * obj0 = 0 ;
35694 char *kwnames[] = {
35695 (char *) "self", NULL
35696 };
35697
35698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
35699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35700 if (SWIG_arg_fail(1)) SWIG_fail;
35701 {
35702 PyThreadState* __tstate = wxPyBeginAllowThreads();
35703 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
35704
35705 wxPyEndAllowThreads(__tstate);
35706 if (PyErr_Occurred()) SWIG_fail;
35707 }
35708 {
35709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35710 }
35711 return resultobj;
35712 fail:
35713 return NULL;
35714 }
35715
35716
35717 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35718 PyObject *resultobj;
35719 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35720 bool arg2 = (bool) true ;
35721 PyObject * obj0 = 0 ;
35722 PyObject * obj1 = 0 ;
35723 char *kwnames[] = {
35724 (char *) "self",(char *) "check", NULL
35725 };
35726
35727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
35728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35729 if (SWIG_arg_fail(1)) SWIG_fail;
35730 if (obj1) {
35731 {
35732 arg2 = (bool)(SWIG_As_bool(obj1));
35733 if (SWIG_arg_fail(2)) SWIG_fail;
35734 }
35735 }
35736 {
35737 PyThreadState* __tstate = wxPyBeginAllowThreads();
35738 (arg1)->Check(arg2);
35739
35740 wxPyEndAllowThreads(__tstate);
35741 if (PyErr_Occurred()) SWIG_fail;
35742 }
35743 Py_INCREF(Py_None); resultobj = Py_None;
35744 return resultobj;
35745 fail:
35746 return NULL;
35747 }
35748
35749
35750 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35751 PyObject *resultobj;
35752 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35753 bool result;
35754 PyObject * obj0 = 0 ;
35755 char *kwnames[] = {
35756 (char *) "self", NULL
35757 };
35758
35759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
35760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35761 if (SWIG_arg_fail(1)) SWIG_fail;
35762 {
35763 PyThreadState* __tstate = wxPyBeginAllowThreads();
35764 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
35765
35766 wxPyEndAllowThreads(__tstate);
35767 if (PyErr_Occurred()) SWIG_fail;
35768 }
35769 {
35770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35771 }
35772 return resultobj;
35773 fail:
35774 return NULL;
35775 }
35776
35777
35778 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
35779 PyObject *resultobj;
35780 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35781 PyObject * obj0 = 0 ;
35782 char *kwnames[] = {
35783 (char *) "self", NULL
35784 };
35785
35786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
35787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35788 if (SWIG_arg_fail(1)) SWIG_fail;
35789 {
35790 PyThreadState* __tstate = wxPyBeginAllowThreads();
35791 (arg1)->Toggle();
35792
35793 wxPyEndAllowThreads(__tstate);
35794 if (PyErr_Occurred()) SWIG_fail;
35795 }
35796 Py_INCREF(Py_None); resultobj = Py_None;
35797 return resultobj;
35798 fail:
35799 return NULL;
35800 }
35801
35802
35803 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
35804 PyObject *resultobj;
35805 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35806 wxString *arg2 = 0 ;
35807 bool temp2 = false ;
35808 PyObject * obj0 = 0 ;
35809 PyObject * obj1 = 0 ;
35810 char *kwnames[] = {
35811 (char *) "self",(char *) "str", NULL
35812 };
35813
35814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
35815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35816 if (SWIG_arg_fail(1)) SWIG_fail;
35817 {
35818 arg2 = wxString_in_helper(obj1);
35819 if (arg2 == NULL) SWIG_fail;
35820 temp2 = true;
35821 }
35822 {
35823 PyThreadState* __tstate = wxPyBeginAllowThreads();
35824 (arg1)->SetHelp((wxString const &)*arg2);
35825
35826 wxPyEndAllowThreads(__tstate);
35827 if (PyErr_Occurred()) SWIG_fail;
35828 }
35829 Py_INCREF(Py_None); resultobj = Py_None;
35830 {
35831 if (temp2)
35832 delete arg2;
35833 }
35834 return resultobj;
35835 fail:
35836 {
35837 if (temp2)
35838 delete arg2;
35839 }
35840 return NULL;
35841 }
35842
35843
35844 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
35845 PyObject *resultobj;
35846 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35847 wxString *result;
35848 PyObject * obj0 = 0 ;
35849 char *kwnames[] = {
35850 (char *) "self", NULL
35851 };
35852
35853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
35854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35855 if (SWIG_arg_fail(1)) SWIG_fail;
35856 {
35857 PyThreadState* __tstate = wxPyBeginAllowThreads();
35858 {
35859 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
35860 result = (wxString *) &_result_ref;
35861 }
35862
35863 wxPyEndAllowThreads(__tstate);
35864 if (PyErr_Occurred()) SWIG_fail;
35865 }
35866 {
35867 #if wxUSE_UNICODE
35868 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35869 #else
35870 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35871 #endif
35872 }
35873 return resultobj;
35874 fail:
35875 return NULL;
35876 }
35877
35878
35879 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
35880 PyObject *resultobj;
35881 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35882 wxAcceleratorEntry *result;
35883 PyObject * obj0 = 0 ;
35884 char *kwnames[] = {
35885 (char *) "self", NULL
35886 };
35887
35888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
35889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35890 if (SWIG_arg_fail(1)) SWIG_fail;
35891 {
35892 PyThreadState* __tstate = wxPyBeginAllowThreads();
35893 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
35894
35895 wxPyEndAllowThreads(__tstate);
35896 if (PyErr_Occurred()) SWIG_fail;
35897 }
35898 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
35899 return resultobj;
35900 fail:
35901 return NULL;
35902 }
35903
35904
35905 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
35906 PyObject *resultobj;
35907 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35908 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
35909 PyObject * obj0 = 0 ;
35910 PyObject * obj1 = 0 ;
35911 char *kwnames[] = {
35912 (char *) "self",(char *) "accel", NULL
35913 };
35914
35915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
35916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35917 if (SWIG_arg_fail(1)) SWIG_fail;
35918 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
35919 if (SWIG_arg_fail(2)) SWIG_fail;
35920 {
35921 PyThreadState* __tstate = wxPyBeginAllowThreads();
35922 (arg1)->SetAccel(arg2);
35923
35924 wxPyEndAllowThreads(__tstate);
35925 if (PyErr_Occurred()) SWIG_fail;
35926 }
35927 Py_INCREF(Py_None); resultobj = Py_None;
35928 return resultobj;
35929 fail:
35930 return NULL;
35931 }
35932
35933
35934 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
35935 PyObject *resultobj;
35936 int result;
35937 char *kwnames[] = {
35938 NULL
35939 };
35940
35941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
35942 {
35943 PyThreadState* __tstate = wxPyBeginAllowThreads();
35944 result = (int)MenuItem_GetDefaultMarginWidth();
35945
35946 wxPyEndAllowThreads(__tstate);
35947 if (PyErr_Occurred()) SWIG_fail;
35948 }
35949 {
35950 resultobj = SWIG_From_int((int)(result));
35951 }
35952 return resultobj;
35953 fail:
35954 return NULL;
35955 }
35956
35957
35958 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
35959 PyObject *resultobj;
35960 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35961 wxBitmap *arg2 = 0 ;
35962 PyObject * obj0 = 0 ;
35963 PyObject * obj1 = 0 ;
35964 char *kwnames[] = {
35965 (char *) "self",(char *) "bitmap", NULL
35966 };
35967
35968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
35969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35970 if (SWIG_arg_fail(1)) SWIG_fail;
35971 {
35972 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
35973 if (SWIG_arg_fail(2)) SWIG_fail;
35974 if (arg2 == NULL) {
35975 SWIG_null_ref("wxBitmap");
35976 }
35977 if (SWIG_arg_fail(2)) SWIG_fail;
35978 }
35979 {
35980 PyThreadState* __tstate = wxPyBeginAllowThreads();
35981 (arg1)->SetBitmap((wxBitmap const &)*arg2);
35982
35983 wxPyEndAllowThreads(__tstate);
35984 if (PyErr_Occurred()) SWIG_fail;
35985 }
35986 Py_INCREF(Py_None); resultobj = Py_None;
35987 return resultobj;
35988 fail:
35989 return NULL;
35990 }
35991
35992
35993 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
35994 PyObject *resultobj;
35995 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35996 wxBitmap *result;
35997 PyObject * obj0 = 0 ;
35998 char *kwnames[] = {
35999 (char *) "self", NULL
36000 };
36001
36002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
36003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36004 if (SWIG_arg_fail(1)) SWIG_fail;
36005 {
36006 PyThreadState* __tstate = wxPyBeginAllowThreads();
36007 {
36008 wxBitmap const &_result_ref = (arg1)->GetBitmap();
36009 result = (wxBitmap *) &_result_ref;
36010 }
36011
36012 wxPyEndAllowThreads(__tstate);
36013 if (PyErr_Occurred()) SWIG_fail;
36014 }
36015 {
36016 wxBitmap* resultptr = new wxBitmap(*result);
36017 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36018 }
36019 return resultobj;
36020 fail:
36021 return NULL;
36022 }
36023
36024
36025 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
36026 PyObject *obj;
36027 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36028 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
36029 Py_INCREF(obj);
36030 return Py_BuildValue((char *)"");
36031 }
36032 static int _wrap_ControlNameStr_set(PyObject *) {
36033 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
36034 return 1;
36035 }
36036
36037
36038 static PyObject *_wrap_ControlNameStr_get(void) {
36039 PyObject *pyobj;
36040
36041 {
36042 #if wxUSE_UNICODE
36043 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36044 #else
36045 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36046 #endif
36047 }
36048 return pyobj;
36049 }
36050
36051
36052 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
36053 PyObject *resultobj;
36054 wxWindow *arg1 = (wxWindow *) 0 ;
36055 int arg2 = (int) -1 ;
36056 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36057 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36058 wxSize const &arg4_defvalue = wxDefaultSize ;
36059 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
36060 long arg5 = (long) 0 ;
36061 wxValidator const &arg6_defvalue = wxDefaultValidator ;
36062 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
36063 wxString const &arg7_defvalue = wxPyControlNameStr ;
36064 wxString *arg7 = (wxString *) &arg7_defvalue ;
36065 wxControl *result;
36066 wxPoint temp3 ;
36067 wxSize temp4 ;
36068 bool temp7 = false ;
36069 PyObject * obj0 = 0 ;
36070 PyObject * obj1 = 0 ;
36071 PyObject * obj2 = 0 ;
36072 PyObject * obj3 = 0 ;
36073 PyObject * obj4 = 0 ;
36074 PyObject * obj5 = 0 ;
36075 PyObject * obj6 = 0 ;
36076 char *kwnames[] = {
36077 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36078 };
36079
36080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
36081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36082 if (SWIG_arg_fail(1)) SWIG_fail;
36083 if (obj1) {
36084 {
36085 arg2 = (int)(SWIG_As_int(obj1));
36086 if (SWIG_arg_fail(2)) SWIG_fail;
36087 }
36088 }
36089 if (obj2) {
36090 {
36091 arg3 = &temp3;
36092 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36093 }
36094 }
36095 if (obj3) {
36096 {
36097 arg4 = &temp4;
36098 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
36099 }
36100 }
36101 if (obj4) {
36102 {
36103 arg5 = (long)(SWIG_As_long(obj4));
36104 if (SWIG_arg_fail(5)) SWIG_fail;
36105 }
36106 }
36107 if (obj5) {
36108 {
36109 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36110 if (SWIG_arg_fail(6)) SWIG_fail;
36111 if (arg6 == NULL) {
36112 SWIG_null_ref("wxValidator");
36113 }
36114 if (SWIG_arg_fail(6)) SWIG_fail;
36115 }
36116 }
36117 if (obj6) {
36118 {
36119 arg7 = wxString_in_helper(obj6);
36120 if (arg7 == NULL) SWIG_fail;
36121 temp7 = true;
36122 }
36123 }
36124 {
36125 if (!wxPyCheckForApp()) SWIG_fail;
36126 PyThreadState* __tstate = wxPyBeginAllowThreads();
36127 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
36128
36129 wxPyEndAllowThreads(__tstate);
36130 if (PyErr_Occurred()) SWIG_fail;
36131 }
36132 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36133 {
36134 if (temp7)
36135 delete arg7;
36136 }
36137 return resultobj;
36138 fail:
36139 {
36140 if (temp7)
36141 delete arg7;
36142 }
36143 return NULL;
36144 }
36145
36146
36147 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
36148 PyObject *resultobj;
36149 wxControl *result;
36150 char *kwnames[] = {
36151 NULL
36152 };
36153
36154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
36155 {
36156 if (!wxPyCheckForApp()) SWIG_fail;
36157 PyThreadState* __tstate = wxPyBeginAllowThreads();
36158 result = (wxControl *)new wxControl();
36159
36160 wxPyEndAllowThreads(__tstate);
36161 if (PyErr_Occurred()) SWIG_fail;
36162 }
36163 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36164 return resultobj;
36165 fail:
36166 return NULL;
36167 }
36168
36169
36170 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
36171 PyObject *resultobj;
36172 wxControl *arg1 = (wxControl *) 0 ;
36173 wxWindow *arg2 = (wxWindow *) 0 ;
36174 int arg3 = (int) -1 ;
36175 wxPoint const &arg4_defvalue = wxDefaultPosition ;
36176 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
36177 wxSize const &arg5_defvalue = wxDefaultSize ;
36178 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
36179 long arg6 = (long) 0 ;
36180 wxValidator const &arg7_defvalue = wxDefaultValidator ;
36181 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
36182 wxString const &arg8_defvalue = wxPyControlNameStr ;
36183 wxString *arg8 = (wxString *) &arg8_defvalue ;
36184 bool result;
36185 wxPoint temp4 ;
36186 wxSize temp5 ;
36187 bool temp8 = false ;
36188 PyObject * obj0 = 0 ;
36189 PyObject * obj1 = 0 ;
36190 PyObject * obj2 = 0 ;
36191 PyObject * obj3 = 0 ;
36192 PyObject * obj4 = 0 ;
36193 PyObject * obj5 = 0 ;
36194 PyObject * obj6 = 0 ;
36195 PyObject * obj7 = 0 ;
36196 char *kwnames[] = {
36197 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36198 };
36199
36200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
36201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36202 if (SWIG_arg_fail(1)) SWIG_fail;
36203 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36204 if (SWIG_arg_fail(2)) SWIG_fail;
36205 if (obj2) {
36206 {
36207 arg3 = (int)(SWIG_As_int(obj2));
36208 if (SWIG_arg_fail(3)) SWIG_fail;
36209 }
36210 }
36211 if (obj3) {
36212 {
36213 arg4 = &temp4;
36214 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
36215 }
36216 }
36217 if (obj4) {
36218 {
36219 arg5 = &temp5;
36220 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
36221 }
36222 }
36223 if (obj5) {
36224 {
36225 arg6 = (long)(SWIG_As_long(obj5));
36226 if (SWIG_arg_fail(6)) SWIG_fail;
36227 }
36228 }
36229 if (obj6) {
36230 {
36231 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36232 if (SWIG_arg_fail(7)) SWIG_fail;
36233 if (arg7 == NULL) {
36234 SWIG_null_ref("wxValidator");
36235 }
36236 if (SWIG_arg_fail(7)) SWIG_fail;
36237 }
36238 }
36239 if (obj7) {
36240 {
36241 arg8 = wxString_in_helper(obj7);
36242 if (arg8 == NULL) SWIG_fail;
36243 temp8 = true;
36244 }
36245 }
36246 {
36247 PyThreadState* __tstate = wxPyBeginAllowThreads();
36248 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
36249
36250 wxPyEndAllowThreads(__tstate);
36251 if (PyErr_Occurred()) SWIG_fail;
36252 }
36253 {
36254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36255 }
36256 {
36257 if (temp8)
36258 delete arg8;
36259 }
36260 return resultobj;
36261 fail:
36262 {
36263 if (temp8)
36264 delete arg8;
36265 }
36266 return NULL;
36267 }
36268
36269
36270 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
36271 PyObject *resultobj;
36272 wxControl *arg1 = (wxControl *) 0 ;
36273 wxCommandEvent *arg2 = 0 ;
36274 PyObject * obj0 = 0 ;
36275 PyObject * obj1 = 0 ;
36276 char *kwnames[] = {
36277 (char *) "self",(char *) "event", NULL
36278 };
36279
36280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
36281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36282 if (SWIG_arg_fail(1)) SWIG_fail;
36283 {
36284 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
36285 if (SWIG_arg_fail(2)) SWIG_fail;
36286 if (arg2 == NULL) {
36287 SWIG_null_ref("wxCommandEvent");
36288 }
36289 if (SWIG_arg_fail(2)) SWIG_fail;
36290 }
36291 {
36292 PyThreadState* __tstate = wxPyBeginAllowThreads();
36293 (arg1)->Command(*arg2);
36294
36295 wxPyEndAllowThreads(__tstate);
36296 if (PyErr_Occurred()) SWIG_fail;
36297 }
36298 Py_INCREF(Py_None); resultobj = Py_None;
36299 return resultobj;
36300 fail:
36301 return NULL;
36302 }
36303
36304
36305 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36306 PyObject *resultobj;
36307 wxControl *arg1 = (wxControl *) 0 ;
36308 wxString result;
36309 PyObject * obj0 = 0 ;
36310 char *kwnames[] = {
36311 (char *) "self", NULL
36312 };
36313
36314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
36315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36316 if (SWIG_arg_fail(1)) SWIG_fail;
36317 {
36318 PyThreadState* __tstate = wxPyBeginAllowThreads();
36319 result = (arg1)->GetLabel();
36320
36321 wxPyEndAllowThreads(__tstate);
36322 if (PyErr_Occurred()) SWIG_fail;
36323 }
36324 {
36325 #if wxUSE_UNICODE
36326 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36327 #else
36328 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36329 #endif
36330 }
36331 return resultobj;
36332 fail:
36333 return NULL;
36334 }
36335
36336
36337 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36338 PyObject *resultobj;
36339 wxControl *arg1 = (wxControl *) 0 ;
36340 wxString *arg2 = 0 ;
36341 bool temp2 = false ;
36342 PyObject * obj0 = 0 ;
36343 PyObject * obj1 = 0 ;
36344 char *kwnames[] = {
36345 (char *) "self",(char *) "label", NULL
36346 };
36347
36348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
36349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36350 if (SWIG_arg_fail(1)) SWIG_fail;
36351 {
36352 arg2 = wxString_in_helper(obj1);
36353 if (arg2 == NULL) SWIG_fail;
36354 temp2 = true;
36355 }
36356 {
36357 PyThreadState* __tstate = wxPyBeginAllowThreads();
36358 (arg1)->SetLabel((wxString const &)*arg2);
36359
36360 wxPyEndAllowThreads(__tstate);
36361 if (PyErr_Occurred()) SWIG_fail;
36362 }
36363 Py_INCREF(Py_None); resultobj = Py_None;
36364 {
36365 if (temp2)
36366 delete arg2;
36367 }
36368 return resultobj;
36369 fail:
36370 {
36371 if (temp2)
36372 delete arg2;
36373 }
36374 return NULL;
36375 }
36376
36377
36378 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
36379 PyObject *resultobj;
36380 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
36381 wxVisualAttributes result;
36382 PyObject * obj0 = 0 ;
36383 char *kwnames[] = {
36384 (char *) "variant", NULL
36385 };
36386
36387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
36388 if (obj0) {
36389 {
36390 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
36391 if (SWIG_arg_fail(1)) SWIG_fail;
36392 }
36393 }
36394 {
36395 if (!wxPyCheckForApp()) SWIG_fail;
36396 PyThreadState* __tstate = wxPyBeginAllowThreads();
36397 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
36398
36399 wxPyEndAllowThreads(__tstate);
36400 if (PyErr_Occurred()) SWIG_fail;
36401 }
36402 {
36403 wxVisualAttributes * resultptr;
36404 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
36405 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
36406 }
36407 return resultobj;
36408 fail:
36409 return NULL;
36410 }
36411
36412
36413 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
36414 PyObject *obj;
36415 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36416 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
36417 Py_INCREF(obj);
36418 return Py_BuildValue((char *)"");
36419 }
36420 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
36421 PyObject *resultobj;
36422 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36423 wxString *arg2 = 0 ;
36424 PyObject *arg3 = (PyObject *) NULL ;
36425 int result;
36426 bool temp2 = false ;
36427 PyObject * obj0 = 0 ;
36428 PyObject * obj1 = 0 ;
36429 PyObject * obj2 = 0 ;
36430 char *kwnames[] = {
36431 (char *) "self",(char *) "item",(char *) "clientData", NULL
36432 };
36433
36434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
36435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36436 if (SWIG_arg_fail(1)) SWIG_fail;
36437 {
36438 arg2 = wxString_in_helper(obj1);
36439 if (arg2 == NULL) SWIG_fail;
36440 temp2 = true;
36441 }
36442 if (obj2) {
36443 arg3 = obj2;
36444 }
36445 {
36446 PyThreadState* __tstate = wxPyBeginAllowThreads();
36447 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
36448
36449 wxPyEndAllowThreads(__tstate);
36450 if (PyErr_Occurred()) SWIG_fail;
36451 }
36452 {
36453 resultobj = SWIG_From_int((int)(result));
36454 }
36455 {
36456 if (temp2)
36457 delete arg2;
36458 }
36459 return resultobj;
36460 fail:
36461 {
36462 if (temp2)
36463 delete arg2;
36464 }
36465 return NULL;
36466 }
36467
36468
36469 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
36470 PyObject *resultobj;
36471 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36472 wxArrayString *arg2 = 0 ;
36473 bool temp2 = false ;
36474 PyObject * obj0 = 0 ;
36475 PyObject * obj1 = 0 ;
36476 char *kwnames[] = {
36477 (char *) "self",(char *) "strings", NULL
36478 };
36479
36480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
36481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36482 if (SWIG_arg_fail(1)) SWIG_fail;
36483 {
36484 if (! PySequence_Check(obj1)) {
36485 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
36486 SWIG_fail;
36487 }
36488 arg2 = new wxArrayString;
36489 temp2 = true;
36490 int i, len=PySequence_Length(obj1);
36491 for (i=0; i<len; i++) {
36492 PyObject* item = PySequence_GetItem(obj1, i);
36493 #if wxUSE_UNICODE
36494 PyObject* str = PyObject_Unicode(item);
36495 #else
36496 PyObject* str = PyObject_Str(item);
36497 #endif
36498 if (PyErr_Occurred()) SWIG_fail;
36499 arg2->Add(Py2wxString(str));
36500 Py_DECREF(item);
36501 Py_DECREF(str);
36502 }
36503 }
36504 {
36505 PyThreadState* __tstate = wxPyBeginAllowThreads();
36506 (arg1)->Append((wxArrayString const &)*arg2);
36507
36508 wxPyEndAllowThreads(__tstate);
36509 if (PyErr_Occurred()) SWIG_fail;
36510 }
36511 Py_INCREF(Py_None); resultobj = Py_None;
36512 {
36513 if (temp2) delete arg2;
36514 }
36515 return resultobj;
36516 fail:
36517 {
36518 if (temp2) delete arg2;
36519 }
36520 return NULL;
36521 }
36522
36523
36524 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
36525 PyObject *resultobj;
36526 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36527 wxString *arg2 = 0 ;
36528 int arg3 ;
36529 PyObject *arg4 = (PyObject *) NULL ;
36530 int result;
36531 bool temp2 = false ;
36532 PyObject * obj0 = 0 ;
36533 PyObject * obj1 = 0 ;
36534 PyObject * obj2 = 0 ;
36535 PyObject * obj3 = 0 ;
36536 char *kwnames[] = {
36537 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
36538 };
36539
36540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
36541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36542 if (SWIG_arg_fail(1)) SWIG_fail;
36543 {
36544 arg2 = wxString_in_helper(obj1);
36545 if (arg2 == NULL) SWIG_fail;
36546 temp2 = true;
36547 }
36548 {
36549 arg3 = (int)(SWIG_As_int(obj2));
36550 if (SWIG_arg_fail(3)) SWIG_fail;
36551 }
36552 if (obj3) {
36553 arg4 = obj3;
36554 }
36555 {
36556 PyThreadState* __tstate = wxPyBeginAllowThreads();
36557 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
36558
36559 wxPyEndAllowThreads(__tstate);
36560 if (PyErr_Occurred()) SWIG_fail;
36561 }
36562 {
36563 resultobj = SWIG_From_int((int)(result));
36564 }
36565 {
36566 if (temp2)
36567 delete arg2;
36568 }
36569 return resultobj;
36570 fail:
36571 {
36572 if (temp2)
36573 delete arg2;
36574 }
36575 return NULL;
36576 }
36577
36578
36579 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
36580 PyObject *resultobj;
36581 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36582 PyObject * obj0 = 0 ;
36583 char *kwnames[] = {
36584 (char *) "self", NULL
36585 };
36586
36587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
36588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36589 if (SWIG_arg_fail(1)) SWIG_fail;
36590 {
36591 PyThreadState* __tstate = wxPyBeginAllowThreads();
36592 (arg1)->Clear();
36593
36594 wxPyEndAllowThreads(__tstate);
36595 if (PyErr_Occurred()) SWIG_fail;
36596 }
36597 Py_INCREF(Py_None); resultobj = Py_None;
36598 return resultobj;
36599 fail:
36600 return NULL;
36601 }
36602
36603
36604 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
36605 PyObject *resultobj;
36606 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36607 int arg2 ;
36608 PyObject * obj0 = 0 ;
36609 PyObject * obj1 = 0 ;
36610 char *kwnames[] = {
36611 (char *) "self",(char *) "n", NULL
36612 };
36613
36614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
36615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36616 if (SWIG_arg_fail(1)) SWIG_fail;
36617 {
36618 arg2 = (int)(SWIG_As_int(obj1));
36619 if (SWIG_arg_fail(2)) SWIG_fail;
36620 }
36621 {
36622 PyThreadState* __tstate = wxPyBeginAllowThreads();
36623 (arg1)->Delete(arg2);
36624
36625 wxPyEndAllowThreads(__tstate);
36626 if (PyErr_Occurred()) SWIG_fail;
36627 }
36628 Py_INCREF(Py_None); resultobj = Py_None;
36629 return resultobj;
36630 fail:
36631 return NULL;
36632 }
36633
36634
36635 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
36636 PyObject *resultobj;
36637 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36638 int arg2 ;
36639 PyObject *result;
36640 PyObject * obj0 = 0 ;
36641 PyObject * obj1 = 0 ;
36642 char *kwnames[] = {
36643 (char *) "self",(char *) "n", NULL
36644 };
36645
36646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
36647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36648 if (SWIG_arg_fail(1)) SWIG_fail;
36649 {
36650 arg2 = (int)(SWIG_As_int(obj1));
36651 if (SWIG_arg_fail(2)) SWIG_fail;
36652 }
36653 {
36654 PyThreadState* __tstate = wxPyBeginAllowThreads();
36655 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
36656
36657 wxPyEndAllowThreads(__tstate);
36658 if (PyErr_Occurred()) SWIG_fail;
36659 }
36660 resultobj = result;
36661 return resultobj;
36662 fail:
36663 return NULL;
36664 }
36665
36666
36667 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
36668 PyObject *resultobj;
36669 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36670 int arg2 ;
36671 PyObject *arg3 = (PyObject *) 0 ;
36672 PyObject * obj0 = 0 ;
36673 PyObject * obj1 = 0 ;
36674 PyObject * obj2 = 0 ;
36675 char *kwnames[] = {
36676 (char *) "self",(char *) "n",(char *) "clientData", NULL
36677 };
36678
36679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
36680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36681 if (SWIG_arg_fail(1)) SWIG_fail;
36682 {
36683 arg2 = (int)(SWIG_As_int(obj1));
36684 if (SWIG_arg_fail(2)) SWIG_fail;
36685 }
36686 arg3 = obj2;
36687 {
36688 PyThreadState* __tstate = wxPyBeginAllowThreads();
36689 wxItemContainer_SetClientData(arg1,arg2,arg3);
36690
36691 wxPyEndAllowThreads(__tstate);
36692 if (PyErr_Occurred()) SWIG_fail;
36693 }
36694 Py_INCREF(Py_None); resultobj = Py_None;
36695 return resultobj;
36696 fail:
36697 return NULL;
36698 }
36699
36700
36701 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
36702 PyObject *resultobj;
36703 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36704 int result;
36705 PyObject * obj0 = 0 ;
36706 char *kwnames[] = {
36707 (char *) "self", NULL
36708 };
36709
36710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
36711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36712 if (SWIG_arg_fail(1)) SWIG_fail;
36713 {
36714 PyThreadState* __tstate = wxPyBeginAllowThreads();
36715 result = (int)((wxItemContainer const *)arg1)->GetCount();
36716
36717 wxPyEndAllowThreads(__tstate);
36718 if (PyErr_Occurred()) SWIG_fail;
36719 }
36720 {
36721 resultobj = SWIG_From_int((int)(result));
36722 }
36723 return resultobj;
36724 fail:
36725 return NULL;
36726 }
36727
36728
36729 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
36730 PyObject *resultobj;
36731 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36732 bool result;
36733 PyObject * obj0 = 0 ;
36734 char *kwnames[] = {
36735 (char *) "self", NULL
36736 };
36737
36738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
36739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36740 if (SWIG_arg_fail(1)) SWIG_fail;
36741 {
36742 PyThreadState* __tstate = wxPyBeginAllowThreads();
36743 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
36744
36745 wxPyEndAllowThreads(__tstate);
36746 if (PyErr_Occurred()) SWIG_fail;
36747 }
36748 {
36749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36750 }
36751 return resultobj;
36752 fail:
36753 return NULL;
36754 }
36755
36756
36757 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
36758 PyObject *resultobj;
36759 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36760 int arg2 ;
36761 wxString result;
36762 PyObject * obj0 = 0 ;
36763 PyObject * obj1 = 0 ;
36764 char *kwnames[] = {
36765 (char *) "self",(char *) "n", NULL
36766 };
36767
36768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
36769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36770 if (SWIG_arg_fail(1)) SWIG_fail;
36771 {
36772 arg2 = (int)(SWIG_As_int(obj1));
36773 if (SWIG_arg_fail(2)) SWIG_fail;
36774 }
36775 {
36776 PyThreadState* __tstate = wxPyBeginAllowThreads();
36777 result = ((wxItemContainer const *)arg1)->GetString(arg2);
36778
36779 wxPyEndAllowThreads(__tstate);
36780 if (PyErr_Occurred()) SWIG_fail;
36781 }
36782 {
36783 #if wxUSE_UNICODE
36784 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36785 #else
36786 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36787 #endif
36788 }
36789 return resultobj;
36790 fail:
36791 return NULL;
36792 }
36793
36794
36795 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
36796 PyObject *resultobj;
36797 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36798 wxArrayString result;
36799 PyObject * obj0 = 0 ;
36800 char *kwnames[] = {
36801 (char *) "self", NULL
36802 };
36803
36804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
36805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36806 if (SWIG_arg_fail(1)) SWIG_fail;
36807 {
36808 PyThreadState* __tstate = wxPyBeginAllowThreads();
36809 result = ((wxItemContainer const *)arg1)->GetStrings();
36810
36811 wxPyEndAllowThreads(__tstate);
36812 if (PyErr_Occurred()) SWIG_fail;
36813 }
36814 {
36815 resultobj = wxArrayString2PyList_helper(result);
36816 }
36817 return resultobj;
36818 fail:
36819 return NULL;
36820 }
36821
36822
36823 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
36824 PyObject *resultobj;
36825 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36826 int arg2 ;
36827 wxString *arg3 = 0 ;
36828 bool temp3 = false ;
36829 PyObject * obj0 = 0 ;
36830 PyObject * obj1 = 0 ;
36831 PyObject * obj2 = 0 ;
36832 char *kwnames[] = {
36833 (char *) "self",(char *) "n",(char *) "s", NULL
36834 };
36835
36836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
36837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36838 if (SWIG_arg_fail(1)) SWIG_fail;
36839 {
36840 arg2 = (int)(SWIG_As_int(obj1));
36841 if (SWIG_arg_fail(2)) SWIG_fail;
36842 }
36843 {
36844 arg3 = wxString_in_helper(obj2);
36845 if (arg3 == NULL) SWIG_fail;
36846 temp3 = true;
36847 }
36848 {
36849 PyThreadState* __tstate = wxPyBeginAllowThreads();
36850 (arg1)->SetString(arg2,(wxString const &)*arg3);
36851
36852 wxPyEndAllowThreads(__tstate);
36853 if (PyErr_Occurred()) SWIG_fail;
36854 }
36855 Py_INCREF(Py_None); resultobj = Py_None;
36856 {
36857 if (temp3)
36858 delete arg3;
36859 }
36860 return resultobj;
36861 fail:
36862 {
36863 if (temp3)
36864 delete arg3;
36865 }
36866 return NULL;
36867 }
36868
36869
36870 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
36871 PyObject *resultobj;
36872 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36873 wxString *arg2 = 0 ;
36874 int result;
36875 bool temp2 = false ;
36876 PyObject * obj0 = 0 ;
36877 PyObject * obj1 = 0 ;
36878 char *kwnames[] = {
36879 (char *) "self",(char *) "s", NULL
36880 };
36881
36882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
36883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36884 if (SWIG_arg_fail(1)) SWIG_fail;
36885 {
36886 arg2 = wxString_in_helper(obj1);
36887 if (arg2 == NULL) SWIG_fail;
36888 temp2 = true;
36889 }
36890 {
36891 PyThreadState* __tstate = wxPyBeginAllowThreads();
36892 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
36893
36894 wxPyEndAllowThreads(__tstate);
36895 if (PyErr_Occurred()) SWIG_fail;
36896 }
36897 {
36898 resultobj = SWIG_From_int((int)(result));
36899 }
36900 {
36901 if (temp2)
36902 delete arg2;
36903 }
36904 return resultobj;
36905 fail:
36906 {
36907 if (temp2)
36908 delete arg2;
36909 }
36910 return NULL;
36911 }
36912
36913
36914 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
36915 PyObject *resultobj;
36916 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36917 int arg2 ;
36918 PyObject * obj0 = 0 ;
36919 PyObject * obj1 = 0 ;
36920 char *kwnames[] = {
36921 (char *) "self",(char *) "n", NULL
36922 };
36923
36924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
36925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36926 if (SWIG_arg_fail(1)) SWIG_fail;
36927 {
36928 arg2 = (int)(SWIG_As_int(obj1));
36929 if (SWIG_arg_fail(2)) SWIG_fail;
36930 }
36931 {
36932 PyThreadState* __tstate = wxPyBeginAllowThreads();
36933 (arg1)->SetSelection(arg2);
36934
36935 wxPyEndAllowThreads(__tstate);
36936 if (PyErr_Occurred()) SWIG_fail;
36937 }
36938 Py_INCREF(Py_None); resultobj = Py_None;
36939 return resultobj;
36940 fail:
36941 return NULL;
36942 }
36943
36944
36945 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
36946 PyObject *resultobj;
36947 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36948 int result;
36949 PyObject * obj0 = 0 ;
36950 char *kwnames[] = {
36951 (char *) "self", NULL
36952 };
36953
36954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
36955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36956 if (SWIG_arg_fail(1)) SWIG_fail;
36957 {
36958 PyThreadState* __tstate = wxPyBeginAllowThreads();
36959 result = (int)((wxItemContainer const *)arg1)->GetSelection();
36960
36961 wxPyEndAllowThreads(__tstate);
36962 if (PyErr_Occurred()) SWIG_fail;
36963 }
36964 {
36965 resultobj = SWIG_From_int((int)(result));
36966 }
36967 return resultobj;
36968 fail:
36969 return NULL;
36970 }
36971
36972
36973 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
36974 PyObject *resultobj;
36975 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36976 wxString *arg2 = 0 ;
36977 bool result;
36978 bool temp2 = false ;
36979 PyObject * obj0 = 0 ;
36980 PyObject * obj1 = 0 ;
36981 char *kwnames[] = {
36982 (char *) "self",(char *) "s", NULL
36983 };
36984
36985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
36986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36987 if (SWIG_arg_fail(1)) SWIG_fail;
36988 {
36989 arg2 = wxString_in_helper(obj1);
36990 if (arg2 == NULL) SWIG_fail;
36991 temp2 = true;
36992 }
36993 {
36994 PyThreadState* __tstate = wxPyBeginAllowThreads();
36995 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
36996
36997 wxPyEndAllowThreads(__tstate);
36998 if (PyErr_Occurred()) SWIG_fail;
36999 }
37000 {
37001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37002 }
37003 {
37004 if (temp2)
37005 delete arg2;
37006 }
37007 return resultobj;
37008 fail:
37009 {
37010 if (temp2)
37011 delete arg2;
37012 }
37013 return NULL;
37014 }
37015
37016
37017 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37018 PyObject *resultobj;
37019 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37020 wxString result;
37021 PyObject * obj0 = 0 ;
37022 char *kwnames[] = {
37023 (char *) "self", NULL
37024 };
37025
37026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
37027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37028 if (SWIG_arg_fail(1)) SWIG_fail;
37029 {
37030 PyThreadState* __tstate = wxPyBeginAllowThreads();
37031 result = ((wxItemContainer const *)arg1)->GetStringSelection();
37032
37033 wxPyEndAllowThreads(__tstate);
37034 if (PyErr_Occurred()) SWIG_fail;
37035 }
37036 {
37037 #if wxUSE_UNICODE
37038 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37039 #else
37040 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37041 #endif
37042 }
37043 return resultobj;
37044 fail:
37045 return NULL;
37046 }
37047
37048
37049 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
37050 PyObject *resultobj;
37051 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37052 int arg2 ;
37053 PyObject * obj0 = 0 ;
37054 PyObject * obj1 = 0 ;
37055 char *kwnames[] = {
37056 (char *) "self",(char *) "n", NULL
37057 };
37058
37059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
37060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37061 if (SWIG_arg_fail(1)) SWIG_fail;
37062 {
37063 arg2 = (int)(SWIG_As_int(obj1));
37064 if (SWIG_arg_fail(2)) SWIG_fail;
37065 }
37066 {
37067 PyThreadState* __tstate = wxPyBeginAllowThreads();
37068 (arg1)->Select(arg2);
37069
37070 wxPyEndAllowThreads(__tstate);
37071 if (PyErr_Occurred()) SWIG_fail;
37072 }
37073 Py_INCREF(Py_None); resultobj = Py_None;
37074 return resultobj;
37075 fail:
37076 return NULL;
37077 }
37078
37079
37080 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
37081 PyObject *obj;
37082 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37083 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
37084 Py_INCREF(obj);
37085 return Py_BuildValue((char *)"");
37086 }
37087 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
37088 PyObject *obj;
37089 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37090 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
37091 Py_INCREF(obj);
37092 return Py_BuildValue((char *)"");
37093 }
37094 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
37095 PyObject *resultobj;
37096 wxSizerItem *result;
37097 char *kwnames[] = {
37098 NULL
37099 };
37100
37101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
37102 {
37103 PyThreadState* __tstate = wxPyBeginAllowThreads();
37104 result = (wxSizerItem *)new wxSizerItem();
37105
37106 wxPyEndAllowThreads(__tstate);
37107 if (PyErr_Occurred()) SWIG_fail;
37108 }
37109 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37110 return resultobj;
37111 fail:
37112 return NULL;
37113 }
37114
37115
37116 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37117 PyObject *resultobj;
37118 wxWindow *arg1 = (wxWindow *) 0 ;
37119 int arg2 ;
37120 int arg3 ;
37121 int arg4 ;
37122 PyObject *arg5 = (PyObject *) NULL ;
37123 wxSizerItem *result;
37124 PyObject * obj0 = 0 ;
37125 PyObject * obj1 = 0 ;
37126 PyObject * obj2 = 0 ;
37127 PyObject * obj3 = 0 ;
37128 PyObject * obj4 = 0 ;
37129 char *kwnames[] = {
37130 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37131 };
37132
37133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37135 if (SWIG_arg_fail(1)) SWIG_fail;
37136 {
37137 arg2 = (int)(SWIG_As_int(obj1));
37138 if (SWIG_arg_fail(2)) SWIG_fail;
37139 }
37140 {
37141 arg3 = (int)(SWIG_As_int(obj2));
37142 if (SWIG_arg_fail(3)) SWIG_fail;
37143 }
37144 {
37145 arg4 = (int)(SWIG_As_int(obj3));
37146 if (SWIG_arg_fail(4)) SWIG_fail;
37147 }
37148 if (obj4) {
37149 arg5 = obj4;
37150 }
37151 {
37152 PyThreadState* __tstate = wxPyBeginAllowThreads();
37153 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37154
37155 wxPyEndAllowThreads(__tstate);
37156 if (PyErr_Occurred()) SWIG_fail;
37157 }
37158 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37159 return resultobj;
37160 fail:
37161 return NULL;
37162 }
37163
37164
37165 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37166 PyObject *resultobj;
37167 int arg1 ;
37168 int arg2 ;
37169 int arg3 ;
37170 int arg4 ;
37171 int arg5 ;
37172 PyObject *arg6 = (PyObject *) NULL ;
37173 wxSizerItem *result;
37174 PyObject * obj0 = 0 ;
37175 PyObject * obj1 = 0 ;
37176 PyObject * obj2 = 0 ;
37177 PyObject * obj3 = 0 ;
37178 PyObject * obj4 = 0 ;
37179 PyObject * obj5 = 0 ;
37180 char *kwnames[] = {
37181 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37182 };
37183
37184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
37185 {
37186 arg1 = (int)(SWIG_As_int(obj0));
37187 if (SWIG_arg_fail(1)) SWIG_fail;
37188 }
37189 {
37190 arg2 = (int)(SWIG_As_int(obj1));
37191 if (SWIG_arg_fail(2)) SWIG_fail;
37192 }
37193 {
37194 arg3 = (int)(SWIG_As_int(obj2));
37195 if (SWIG_arg_fail(3)) SWIG_fail;
37196 }
37197 {
37198 arg4 = (int)(SWIG_As_int(obj3));
37199 if (SWIG_arg_fail(4)) SWIG_fail;
37200 }
37201 {
37202 arg5 = (int)(SWIG_As_int(obj4));
37203 if (SWIG_arg_fail(5)) SWIG_fail;
37204 }
37205 if (obj5) {
37206 arg6 = obj5;
37207 }
37208 {
37209 PyThreadState* __tstate = wxPyBeginAllowThreads();
37210 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
37211
37212 wxPyEndAllowThreads(__tstate);
37213 if (PyErr_Occurred()) SWIG_fail;
37214 }
37215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37216 return resultobj;
37217 fail:
37218 return NULL;
37219 }
37220
37221
37222 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37223 PyObject *resultobj;
37224 wxSizer *arg1 = (wxSizer *) 0 ;
37225 int arg2 ;
37226 int arg3 ;
37227 int arg4 ;
37228 PyObject *arg5 = (PyObject *) NULL ;
37229 wxSizerItem *result;
37230 PyObject * obj0 = 0 ;
37231 PyObject * obj1 = 0 ;
37232 PyObject * obj2 = 0 ;
37233 PyObject * obj3 = 0 ;
37234 PyObject * obj4 = 0 ;
37235 char *kwnames[] = {
37236 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37237 };
37238
37239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
37241 if (SWIG_arg_fail(1)) SWIG_fail;
37242 {
37243 arg2 = (int)(SWIG_As_int(obj1));
37244 if (SWIG_arg_fail(2)) SWIG_fail;
37245 }
37246 {
37247 arg3 = (int)(SWIG_As_int(obj2));
37248 if (SWIG_arg_fail(3)) SWIG_fail;
37249 }
37250 {
37251 arg4 = (int)(SWIG_As_int(obj3));
37252 if (SWIG_arg_fail(4)) SWIG_fail;
37253 }
37254 if (obj4) {
37255 arg5 = obj4;
37256 }
37257 {
37258 PyThreadState* __tstate = wxPyBeginAllowThreads();
37259 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37260
37261 wxPyEndAllowThreads(__tstate);
37262 if (PyErr_Occurred()) SWIG_fail;
37263 }
37264 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37265 return resultobj;
37266 fail:
37267 return NULL;
37268 }
37269
37270
37271 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
37272 PyObject *resultobj;
37273 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37274 PyObject * obj0 = 0 ;
37275 char *kwnames[] = {
37276 (char *) "self", NULL
37277 };
37278
37279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
37280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37281 if (SWIG_arg_fail(1)) SWIG_fail;
37282 {
37283 PyThreadState* __tstate = wxPyBeginAllowThreads();
37284 (arg1)->DeleteWindows();
37285
37286 wxPyEndAllowThreads(__tstate);
37287 if (PyErr_Occurred()) SWIG_fail;
37288 }
37289 Py_INCREF(Py_None); resultobj = Py_None;
37290 return resultobj;
37291 fail:
37292 return NULL;
37293 }
37294
37295
37296 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37297 PyObject *resultobj;
37298 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37299 PyObject * obj0 = 0 ;
37300 char *kwnames[] = {
37301 (char *) "self", NULL
37302 };
37303
37304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
37305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37306 if (SWIG_arg_fail(1)) SWIG_fail;
37307 {
37308 PyThreadState* __tstate = wxPyBeginAllowThreads();
37309 (arg1)->DetachSizer();
37310
37311 wxPyEndAllowThreads(__tstate);
37312 if (PyErr_Occurred()) SWIG_fail;
37313 }
37314 Py_INCREF(Py_None); resultobj = Py_None;
37315 return resultobj;
37316 fail:
37317 return NULL;
37318 }
37319
37320
37321 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
37322 PyObject *resultobj;
37323 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37324 wxSize result;
37325 PyObject * obj0 = 0 ;
37326 char *kwnames[] = {
37327 (char *) "self", NULL
37328 };
37329
37330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
37331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37332 if (SWIG_arg_fail(1)) SWIG_fail;
37333 {
37334 PyThreadState* __tstate = wxPyBeginAllowThreads();
37335 result = (arg1)->GetSize();
37336
37337 wxPyEndAllowThreads(__tstate);
37338 if (PyErr_Occurred()) SWIG_fail;
37339 }
37340 {
37341 wxSize * resultptr;
37342 resultptr = new wxSize((wxSize &)(result));
37343 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37344 }
37345 return resultobj;
37346 fail:
37347 return NULL;
37348 }
37349
37350
37351 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
37352 PyObject *resultobj;
37353 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37354 wxSize result;
37355 PyObject * obj0 = 0 ;
37356 char *kwnames[] = {
37357 (char *) "self", NULL
37358 };
37359
37360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
37361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37362 if (SWIG_arg_fail(1)) SWIG_fail;
37363 {
37364 PyThreadState* __tstate = wxPyBeginAllowThreads();
37365 result = (arg1)->CalcMin();
37366
37367 wxPyEndAllowThreads(__tstate);
37368 if (PyErr_Occurred()) SWIG_fail;
37369 }
37370 {
37371 wxSize * resultptr;
37372 resultptr = new wxSize((wxSize &)(result));
37373 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37374 }
37375 return resultobj;
37376 fail:
37377 return NULL;
37378 }
37379
37380
37381 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
37382 PyObject *resultobj;
37383 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37384 wxPoint arg2 ;
37385 wxSize arg3 ;
37386 PyObject * obj0 = 0 ;
37387 PyObject * obj1 = 0 ;
37388 PyObject * obj2 = 0 ;
37389 char *kwnames[] = {
37390 (char *) "self",(char *) "pos",(char *) "size", NULL
37391 };
37392
37393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
37394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37395 if (SWIG_arg_fail(1)) SWIG_fail;
37396 {
37397 wxPoint * argp;
37398 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
37399 if (SWIG_arg_fail(2)) SWIG_fail;
37400 if (argp == NULL) {
37401 SWIG_null_ref("wxPoint");
37402 }
37403 if (SWIG_arg_fail(2)) SWIG_fail;
37404 arg2 = *argp;
37405 }
37406 {
37407 wxSize * argp;
37408 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
37409 if (SWIG_arg_fail(3)) SWIG_fail;
37410 if (argp == NULL) {
37411 SWIG_null_ref("wxSize");
37412 }
37413 if (SWIG_arg_fail(3)) SWIG_fail;
37414 arg3 = *argp;
37415 }
37416 {
37417 PyThreadState* __tstate = wxPyBeginAllowThreads();
37418 (arg1)->SetDimension(arg2,arg3);
37419
37420 wxPyEndAllowThreads(__tstate);
37421 if (PyErr_Occurred()) SWIG_fail;
37422 }
37423 Py_INCREF(Py_None); resultobj = Py_None;
37424 return resultobj;
37425 fail:
37426 return NULL;
37427 }
37428
37429
37430 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
37431 PyObject *resultobj;
37432 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37433 wxSize result;
37434 PyObject * obj0 = 0 ;
37435 char *kwnames[] = {
37436 (char *) "self", NULL
37437 };
37438
37439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
37440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37441 if (SWIG_arg_fail(1)) SWIG_fail;
37442 {
37443 PyThreadState* __tstate = wxPyBeginAllowThreads();
37444 result = (arg1)->GetMinSize();
37445
37446 wxPyEndAllowThreads(__tstate);
37447 if (PyErr_Occurred()) SWIG_fail;
37448 }
37449 {
37450 wxSize * resultptr;
37451 resultptr = new wxSize((wxSize &)(result));
37452 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37453 }
37454 return resultobj;
37455 fail:
37456 return NULL;
37457 }
37458
37459
37460 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37461 PyObject *resultobj;
37462 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37463 wxSize result;
37464 PyObject * obj0 = 0 ;
37465 char *kwnames[] = {
37466 (char *) "self", NULL
37467 };
37468
37469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
37470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37471 if (SWIG_arg_fail(1)) SWIG_fail;
37472 {
37473 PyThreadState* __tstate = wxPyBeginAllowThreads();
37474 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
37475
37476 wxPyEndAllowThreads(__tstate);
37477 if (PyErr_Occurred()) SWIG_fail;
37478 }
37479 {
37480 wxSize * resultptr;
37481 resultptr = new wxSize((wxSize &)(result));
37482 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37483 }
37484 return resultobj;
37485 fail:
37486 return NULL;
37487 }
37488
37489
37490 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
37491 PyObject *resultobj;
37492 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37493 int arg2 ;
37494 int arg3 ;
37495 PyObject * obj0 = 0 ;
37496 PyObject * obj1 = 0 ;
37497 PyObject * obj2 = 0 ;
37498 char *kwnames[] = {
37499 (char *) "self",(char *) "x",(char *) "y", NULL
37500 };
37501
37502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
37503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37504 if (SWIG_arg_fail(1)) SWIG_fail;
37505 {
37506 arg2 = (int)(SWIG_As_int(obj1));
37507 if (SWIG_arg_fail(2)) SWIG_fail;
37508 }
37509 {
37510 arg3 = (int)(SWIG_As_int(obj2));
37511 if (SWIG_arg_fail(3)) SWIG_fail;
37512 }
37513 {
37514 PyThreadState* __tstate = wxPyBeginAllowThreads();
37515 (arg1)->SetInitSize(arg2,arg3);
37516
37517 wxPyEndAllowThreads(__tstate);
37518 if (PyErr_Occurred()) SWIG_fail;
37519 }
37520 Py_INCREF(Py_None); resultobj = Py_None;
37521 return resultobj;
37522 fail:
37523 return NULL;
37524 }
37525
37526
37527 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
37528 PyObject *resultobj;
37529 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37530 int arg2 ;
37531 int arg3 ;
37532 PyObject * obj0 = 0 ;
37533 PyObject * obj1 = 0 ;
37534 PyObject * obj2 = 0 ;
37535 char *kwnames[] = {
37536 (char *) "self",(char *) "width",(char *) "height", NULL
37537 };
37538
37539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
37540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37541 if (SWIG_arg_fail(1)) SWIG_fail;
37542 {
37543 arg2 = (int)(SWIG_As_int(obj1));
37544 if (SWIG_arg_fail(2)) SWIG_fail;
37545 }
37546 {
37547 arg3 = (int)(SWIG_As_int(obj2));
37548 if (SWIG_arg_fail(3)) SWIG_fail;
37549 }
37550 {
37551 PyThreadState* __tstate = wxPyBeginAllowThreads();
37552 (arg1)->SetRatio(arg2,arg3);
37553
37554 wxPyEndAllowThreads(__tstate);
37555 if (PyErr_Occurred()) SWIG_fail;
37556 }
37557 Py_INCREF(Py_None); resultobj = Py_None;
37558 return resultobj;
37559 fail:
37560 return NULL;
37561 }
37562
37563
37564 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
37565 PyObject *resultobj;
37566 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37567 wxSize arg2 ;
37568 PyObject * obj0 = 0 ;
37569 PyObject * obj1 = 0 ;
37570 char *kwnames[] = {
37571 (char *) "self",(char *) "size", NULL
37572 };
37573
37574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
37575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37576 if (SWIG_arg_fail(1)) SWIG_fail;
37577 {
37578 wxSize * argp;
37579 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
37580 if (SWIG_arg_fail(2)) SWIG_fail;
37581 if (argp == NULL) {
37582 SWIG_null_ref("wxSize");
37583 }
37584 if (SWIG_arg_fail(2)) SWIG_fail;
37585 arg2 = *argp;
37586 }
37587 {
37588 PyThreadState* __tstate = wxPyBeginAllowThreads();
37589 (arg1)->SetRatio(arg2);
37590
37591 wxPyEndAllowThreads(__tstate);
37592 if (PyErr_Occurred()) SWIG_fail;
37593 }
37594 Py_INCREF(Py_None); resultobj = Py_None;
37595 return resultobj;
37596 fail:
37597 return NULL;
37598 }
37599
37600
37601 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
37602 PyObject *resultobj;
37603 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37604 float arg2 ;
37605 PyObject * obj0 = 0 ;
37606 PyObject * obj1 = 0 ;
37607 char *kwnames[] = {
37608 (char *) "self",(char *) "ratio", NULL
37609 };
37610
37611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
37612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37613 if (SWIG_arg_fail(1)) SWIG_fail;
37614 {
37615 arg2 = (float)(SWIG_As_float(obj1));
37616 if (SWIG_arg_fail(2)) SWIG_fail;
37617 }
37618 {
37619 PyThreadState* __tstate = wxPyBeginAllowThreads();
37620 (arg1)->SetRatio(arg2);
37621
37622 wxPyEndAllowThreads(__tstate);
37623 if (PyErr_Occurred()) SWIG_fail;
37624 }
37625 Py_INCREF(Py_None); resultobj = Py_None;
37626 return resultobj;
37627 fail:
37628 return NULL;
37629 }
37630
37631
37632 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
37633 PyObject *resultobj;
37634 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37635 float result;
37636 PyObject * obj0 = 0 ;
37637 char *kwnames[] = {
37638 (char *) "self", NULL
37639 };
37640
37641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
37642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37643 if (SWIG_arg_fail(1)) SWIG_fail;
37644 {
37645 PyThreadState* __tstate = wxPyBeginAllowThreads();
37646 result = (float)(arg1)->GetRatio();
37647
37648 wxPyEndAllowThreads(__tstate);
37649 if (PyErr_Occurred()) SWIG_fail;
37650 }
37651 {
37652 resultobj = SWIG_From_float((float)(result));
37653 }
37654 return resultobj;
37655 fail:
37656 return NULL;
37657 }
37658
37659
37660 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
37661 PyObject *resultobj;
37662 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37663 wxRect result;
37664 PyObject * obj0 = 0 ;
37665 char *kwnames[] = {
37666 (char *) "self", NULL
37667 };
37668
37669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
37670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37671 if (SWIG_arg_fail(1)) SWIG_fail;
37672 {
37673 PyThreadState* __tstate = wxPyBeginAllowThreads();
37674 result = (arg1)->GetRect();
37675
37676 wxPyEndAllowThreads(__tstate);
37677 if (PyErr_Occurred()) SWIG_fail;
37678 }
37679 {
37680 wxRect * resultptr;
37681 resultptr = new wxRect((wxRect &)(result));
37682 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
37683 }
37684 return resultobj;
37685 fail:
37686 return NULL;
37687 }
37688
37689
37690 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37691 PyObject *resultobj;
37692 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37693 bool result;
37694 PyObject * obj0 = 0 ;
37695 char *kwnames[] = {
37696 (char *) "self", NULL
37697 };
37698
37699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
37700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37701 if (SWIG_arg_fail(1)) SWIG_fail;
37702 {
37703 PyThreadState* __tstate = wxPyBeginAllowThreads();
37704 result = (bool)(arg1)->IsWindow();
37705
37706 wxPyEndAllowThreads(__tstate);
37707 if (PyErr_Occurred()) SWIG_fail;
37708 }
37709 {
37710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37711 }
37712 return resultobj;
37713 fail:
37714 return NULL;
37715 }
37716
37717
37718 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37719 PyObject *resultobj;
37720 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37721 bool result;
37722 PyObject * obj0 = 0 ;
37723 char *kwnames[] = {
37724 (char *) "self", NULL
37725 };
37726
37727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
37728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37729 if (SWIG_arg_fail(1)) SWIG_fail;
37730 {
37731 PyThreadState* __tstate = wxPyBeginAllowThreads();
37732 result = (bool)(arg1)->IsSizer();
37733
37734 wxPyEndAllowThreads(__tstate);
37735 if (PyErr_Occurred()) SWIG_fail;
37736 }
37737 {
37738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37739 }
37740 return resultobj;
37741 fail:
37742 return NULL;
37743 }
37744
37745
37746 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37747 PyObject *resultobj;
37748 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37749 bool result;
37750 PyObject * obj0 = 0 ;
37751 char *kwnames[] = {
37752 (char *) "self", NULL
37753 };
37754
37755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
37756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37757 if (SWIG_arg_fail(1)) SWIG_fail;
37758 {
37759 PyThreadState* __tstate = wxPyBeginAllowThreads();
37760 result = (bool)(arg1)->IsSpacer();
37761
37762 wxPyEndAllowThreads(__tstate);
37763 if (PyErr_Occurred()) SWIG_fail;
37764 }
37765 {
37766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37767 }
37768 return resultobj;
37769 fail:
37770 return NULL;
37771 }
37772
37773
37774 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
37775 PyObject *resultobj;
37776 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37777 int arg2 ;
37778 PyObject * obj0 = 0 ;
37779 PyObject * obj1 = 0 ;
37780 char *kwnames[] = {
37781 (char *) "self",(char *) "proportion", NULL
37782 };
37783
37784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
37785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37786 if (SWIG_arg_fail(1)) SWIG_fail;
37787 {
37788 arg2 = (int)(SWIG_As_int(obj1));
37789 if (SWIG_arg_fail(2)) SWIG_fail;
37790 }
37791 {
37792 PyThreadState* __tstate = wxPyBeginAllowThreads();
37793 (arg1)->SetProportion(arg2);
37794
37795 wxPyEndAllowThreads(__tstate);
37796 if (PyErr_Occurred()) SWIG_fail;
37797 }
37798 Py_INCREF(Py_None); resultobj = Py_None;
37799 return resultobj;
37800 fail:
37801 return NULL;
37802 }
37803
37804
37805 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
37806 PyObject *resultobj;
37807 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37808 int result;
37809 PyObject * obj0 = 0 ;
37810 char *kwnames[] = {
37811 (char *) "self", NULL
37812 };
37813
37814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
37815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37816 if (SWIG_arg_fail(1)) SWIG_fail;
37817 {
37818 PyThreadState* __tstate = wxPyBeginAllowThreads();
37819 result = (int)(arg1)->GetProportion();
37820
37821 wxPyEndAllowThreads(__tstate);
37822 if (PyErr_Occurred()) SWIG_fail;
37823 }
37824 {
37825 resultobj = SWIG_From_int((int)(result));
37826 }
37827 return resultobj;
37828 fail:
37829 return NULL;
37830 }
37831
37832
37833 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
37834 PyObject *resultobj;
37835 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37836 int arg2 ;
37837 PyObject * obj0 = 0 ;
37838 PyObject * obj1 = 0 ;
37839 char *kwnames[] = {
37840 (char *) "self",(char *) "flag", NULL
37841 };
37842
37843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
37844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37845 if (SWIG_arg_fail(1)) SWIG_fail;
37846 {
37847 arg2 = (int)(SWIG_As_int(obj1));
37848 if (SWIG_arg_fail(2)) SWIG_fail;
37849 }
37850 {
37851 PyThreadState* __tstate = wxPyBeginAllowThreads();
37852 (arg1)->SetFlag(arg2);
37853
37854 wxPyEndAllowThreads(__tstate);
37855 if (PyErr_Occurred()) SWIG_fail;
37856 }
37857 Py_INCREF(Py_None); resultobj = Py_None;
37858 return resultobj;
37859 fail:
37860 return NULL;
37861 }
37862
37863
37864 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
37865 PyObject *resultobj;
37866 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37867 int result;
37868 PyObject * obj0 = 0 ;
37869 char *kwnames[] = {
37870 (char *) "self", NULL
37871 };
37872
37873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
37874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37875 if (SWIG_arg_fail(1)) SWIG_fail;
37876 {
37877 PyThreadState* __tstate = wxPyBeginAllowThreads();
37878 result = (int)(arg1)->GetFlag();
37879
37880 wxPyEndAllowThreads(__tstate);
37881 if (PyErr_Occurred()) SWIG_fail;
37882 }
37883 {
37884 resultobj = SWIG_From_int((int)(result));
37885 }
37886 return resultobj;
37887 fail:
37888 return NULL;
37889 }
37890
37891
37892 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37893 PyObject *resultobj;
37894 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37895 int arg2 ;
37896 PyObject * obj0 = 0 ;
37897 PyObject * obj1 = 0 ;
37898 char *kwnames[] = {
37899 (char *) "self",(char *) "border", NULL
37900 };
37901
37902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
37903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37904 if (SWIG_arg_fail(1)) SWIG_fail;
37905 {
37906 arg2 = (int)(SWIG_As_int(obj1));
37907 if (SWIG_arg_fail(2)) SWIG_fail;
37908 }
37909 {
37910 PyThreadState* __tstate = wxPyBeginAllowThreads();
37911 (arg1)->SetBorder(arg2);
37912
37913 wxPyEndAllowThreads(__tstate);
37914 if (PyErr_Occurred()) SWIG_fail;
37915 }
37916 Py_INCREF(Py_None); resultobj = Py_None;
37917 return resultobj;
37918 fail:
37919 return NULL;
37920 }
37921
37922
37923 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37924 PyObject *resultobj;
37925 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37926 int result;
37927 PyObject * obj0 = 0 ;
37928 char *kwnames[] = {
37929 (char *) "self", NULL
37930 };
37931
37932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
37933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37934 if (SWIG_arg_fail(1)) SWIG_fail;
37935 {
37936 PyThreadState* __tstate = wxPyBeginAllowThreads();
37937 result = (int)(arg1)->GetBorder();
37938
37939 wxPyEndAllowThreads(__tstate);
37940 if (PyErr_Occurred()) SWIG_fail;
37941 }
37942 {
37943 resultobj = SWIG_From_int((int)(result));
37944 }
37945 return resultobj;
37946 fail:
37947 return NULL;
37948 }
37949
37950
37951 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37952 PyObject *resultobj;
37953 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37954 wxWindow *result;
37955 PyObject * obj0 = 0 ;
37956 char *kwnames[] = {
37957 (char *) "self", NULL
37958 };
37959
37960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
37965 result = (wxWindow *)(arg1)->GetWindow();
37966
37967 wxPyEndAllowThreads(__tstate);
37968 if (PyErr_Occurred()) SWIG_fail;
37969 }
37970 {
37971 resultobj = wxPyMake_wxObject(result, 0);
37972 }
37973 return resultobj;
37974 fail:
37975 return NULL;
37976 }
37977
37978
37979 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37980 PyObject *resultobj;
37981 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37982 wxWindow *arg2 = (wxWindow *) 0 ;
37983 PyObject * obj0 = 0 ;
37984 PyObject * obj1 = 0 ;
37985 char *kwnames[] = {
37986 (char *) "self",(char *) "window", NULL
37987 };
37988
37989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
37990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37991 if (SWIG_arg_fail(1)) SWIG_fail;
37992 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37993 if (SWIG_arg_fail(2)) SWIG_fail;
37994 {
37995 PyThreadState* __tstate = wxPyBeginAllowThreads();
37996 (arg1)->SetWindow(arg2);
37997
37998 wxPyEndAllowThreads(__tstate);
37999 if (PyErr_Occurred()) SWIG_fail;
38000 }
38001 Py_INCREF(Py_None); resultobj = Py_None;
38002 return resultobj;
38003 fail:
38004 return NULL;
38005 }
38006
38007
38008 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38009 PyObject *resultobj;
38010 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38011 wxSizer *result;
38012 PyObject * obj0 = 0 ;
38013 char *kwnames[] = {
38014 (char *) "self", NULL
38015 };
38016
38017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
38018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38019 if (SWIG_arg_fail(1)) SWIG_fail;
38020 {
38021 PyThreadState* __tstate = wxPyBeginAllowThreads();
38022 result = (wxSizer *)(arg1)->GetSizer();
38023
38024 wxPyEndAllowThreads(__tstate);
38025 if (PyErr_Occurred()) SWIG_fail;
38026 }
38027 {
38028 resultobj = wxPyMake_wxSizer(result, 0);
38029 }
38030 return resultobj;
38031 fail:
38032 return NULL;
38033 }
38034
38035
38036 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38037 PyObject *resultobj;
38038 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38039 wxSizer *arg2 = (wxSizer *) 0 ;
38040 PyObject * obj0 = 0 ;
38041 PyObject * obj1 = 0 ;
38042 char *kwnames[] = {
38043 (char *) "self",(char *) "sizer", NULL
38044 };
38045
38046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
38047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38048 if (SWIG_arg_fail(1)) SWIG_fail;
38049 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38050 if (SWIG_arg_fail(2)) SWIG_fail;
38051 {
38052 PyThreadState* __tstate = wxPyBeginAllowThreads();
38053 (arg1)->SetSizer(arg2);
38054
38055 wxPyEndAllowThreads(__tstate);
38056 if (PyErr_Occurred()) SWIG_fail;
38057 }
38058 Py_INCREF(Py_None); resultobj = Py_None;
38059 return resultobj;
38060 fail:
38061 return NULL;
38062 }
38063
38064
38065 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38066 PyObject *resultobj;
38067 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38068 wxSize *result;
38069 PyObject * obj0 = 0 ;
38070 char *kwnames[] = {
38071 (char *) "self", NULL
38072 };
38073
38074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
38075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38076 if (SWIG_arg_fail(1)) SWIG_fail;
38077 {
38078 PyThreadState* __tstate = wxPyBeginAllowThreads();
38079 {
38080 wxSize const &_result_ref = (arg1)->GetSpacer();
38081 result = (wxSize *) &_result_ref;
38082 }
38083
38084 wxPyEndAllowThreads(__tstate);
38085 if (PyErr_Occurred()) SWIG_fail;
38086 }
38087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
38088 return resultobj;
38089 fail:
38090 return NULL;
38091 }
38092
38093
38094 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38095 PyObject *resultobj;
38096 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38097 wxSize *arg2 = 0 ;
38098 wxSize temp2 ;
38099 PyObject * obj0 = 0 ;
38100 PyObject * obj1 = 0 ;
38101 char *kwnames[] = {
38102 (char *) "self",(char *) "size", NULL
38103 };
38104
38105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
38106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38107 if (SWIG_arg_fail(1)) SWIG_fail;
38108 {
38109 arg2 = &temp2;
38110 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38111 }
38112 {
38113 PyThreadState* __tstate = wxPyBeginAllowThreads();
38114 (arg1)->SetSpacer((wxSize const &)*arg2);
38115
38116 wxPyEndAllowThreads(__tstate);
38117 if (PyErr_Occurred()) SWIG_fail;
38118 }
38119 Py_INCREF(Py_None); resultobj = Py_None;
38120 return resultobj;
38121 fail:
38122 return NULL;
38123 }
38124
38125
38126 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
38127 PyObject *resultobj;
38128 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38129 bool arg2 ;
38130 PyObject * obj0 = 0 ;
38131 PyObject * obj1 = 0 ;
38132 char *kwnames[] = {
38133 (char *) "self",(char *) "show", NULL
38134 };
38135
38136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
38137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38138 if (SWIG_arg_fail(1)) SWIG_fail;
38139 {
38140 arg2 = (bool)(SWIG_As_bool(obj1));
38141 if (SWIG_arg_fail(2)) SWIG_fail;
38142 }
38143 {
38144 PyThreadState* __tstate = wxPyBeginAllowThreads();
38145 (arg1)->Show(arg2);
38146
38147 wxPyEndAllowThreads(__tstate);
38148 if (PyErr_Occurred()) SWIG_fail;
38149 }
38150 Py_INCREF(Py_None); resultobj = Py_None;
38151 return resultobj;
38152 fail:
38153 return NULL;
38154 }
38155
38156
38157 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
38158 PyObject *resultobj;
38159 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38160 bool result;
38161 PyObject * obj0 = 0 ;
38162 char *kwnames[] = {
38163 (char *) "self", NULL
38164 };
38165
38166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
38167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38168 if (SWIG_arg_fail(1)) SWIG_fail;
38169 {
38170 PyThreadState* __tstate = wxPyBeginAllowThreads();
38171 result = (bool)(arg1)->IsShown();
38172
38173 wxPyEndAllowThreads(__tstate);
38174 if (PyErr_Occurred()) SWIG_fail;
38175 }
38176 {
38177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38178 }
38179 return resultobj;
38180 fail:
38181 return NULL;
38182 }
38183
38184
38185 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38186 PyObject *resultobj;
38187 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38188 wxPoint result;
38189 PyObject * obj0 = 0 ;
38190 char *kwnames[] = {
38191 (char *) "self", NULL
38192 };
38193
38194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
38195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38196 if (SWIG_arg_fail(1)) SWIG_fail;
38197 {
38198 PyThreadState* __tstate = wxPyBeginAllowThreads();
38199 result = (arg1)->GetPosition();
38200
38201 wxPyEndAllowThreads(__tstate);
38202 if (PyErr_Occurred()) SWIG_fail;
38203 }
38204 {
38205 wxPoint * resultptr;
38206 resultptr = new wxPoint((wxPoint &)(result));
38207 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38208 }
38209 return resultobj;
38210 fail:
38211 return NULL;
38212 }
38213
38214
38215 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
38216 PyObject *resultobj;
38217 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38218 PyObject *result;
38219 PyObject * obj0 = 0 ;
38220 char *kwnames[] = {
38221 (char *) "self", NULL
38222 };
38223
38224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
38225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38226 if (SWIG_arg_fail(1)) SWIG_fail;
38227 {
38228 PyThreadState* __tstate = wxPyBeginAllowThreads();
38229 result = (PyObject *)wxSizerItem_GetUserData(arg1);
38230
38231 wxPyEndAllowThreads(__tstate);
38232 if (PyErr_Occurred()) SWIG_fail;
38233 }
38234 resultobj = result;
38235 return resultobj;
38236 fail:
38237 return NULL;
38238 }
38239
38240
38241 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
38242 PyObject *obj;
38243 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38244 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
38245 Py_INCREF(obj);
38246 return Py_BuildValue((char *)"");
38247 }
38248 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
38249 PyObject *resultobj;
38250 wxSizer *arg1 = (wxSizer *) 0 ;
38251 PyObject *arg2 = (PyObject *) 0 ;
38252 PyObject * obj0 = 0 ;
38253 PyObject * obj1 = 0 ;
38254 char *kwnames[] = {
38255 (char *) "self",(char *) "_self", NULL
38256 };
38257
38258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
38259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38260 if (SWIG_arg_fail(1)) SWIG_fail;
38261 arg2 = obj1;
38262 {
38263 PyThreadState* __tstate = wxPyBeginAllowThreads();
38264 wxSizer__setOORInfo(arg1,arg2);
38265
38266 wxPyEndAllowThreads(__tstate);
38267 if (PyErr_Occurred()) SWIG_fail;
38268 }
38269 Py_INCREF(Py_None); resultobj = Py_None;
38270 return resultobj;
38271 fail:
38272 return NULL;
38273 }
38274
38275
38276 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
38277 PyObject *resultobj;
38278 wxSizer *arg1 = (wxSizer *) 0 ;
38279 PyObject *arg2 = (PyObject *) 0 ;
38280 int arg3 = (int) 0 ;
38281 int arg4 = (int) 0 ;
38282 int arg5 = (int) 0 ;
38283 PyObject *arg6 = (PyObject *) NULL ;
38284 wxSizerItem *result;
38285 PyObject * obj0 = 0 ;
38286 PyObject * obj1 = 0 ;
38287 PyObject * obj2 = 0 ;
38288 PyObject * obj3 = 0 ;
38289 PyObject * obj4 = 0 ;
38290 PyObject * obj5 = 0 ;
38291 char *kwnames[] = {
38292 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38293 };
38294
38295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38297 if (SWIG_arg_fail(1)) SWIG_fail;
38298 arg2 = obj1;
38299 if (obj2) {
38300 {
38301 arg3 = (int)(SWIG_As_int(obj2));
38302 if (SWIG_arg_fail(3)) SWIG_fail;
38303 }
38304 }
38305 if (obj3) {
38306 {
38307 arg4 = (int)(SWIG_As_int(obj3));
38308 if (SWIG_arg_fail(4)) SWIG_fail;
38309 }
38310 }
38311 if (obj4) {
38312 {
38313 arg5 = (int)(SWIG_As_int(obj4));
38314 if (SWIG_arg_fail(5)) SWIG_fail;
38315 }
38316 }
38317 if (obj5) {
38318 arg6 = obj5;
38319 }
38320 {
38321 PyThreadState* __tstate = wxPyBeginAllowThreads();
38322 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
38323
38324 wxPyEndAllowThreads(__tstate);
38325 if (PyErr_Occurred()) SWIG_fail;
38326 }
38327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38328 return resultobj;
38329 fail:
38330 return NULL;
38331 }
38332
38333
38334 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38335 PyObject *resultobj;
38336 wxSizer *arg1 = (wxSizer *) 0 ;
38337 int arg2 ;
38338 PyObject *arg3 = (PyObject *) 0 ;
38339 int arg4 = (int) 0 ;
38340 int arg5 = (int) 0 ;
38341 int arg6 = (int) 0 ;
38342 PyObject *arg7 = (PyObject *) NULL ;
38343 wxSizerItem *result;
38344 PyObject * obj0 = 0 ;
38345 PyObject * obj1 = 0 ;
38346 PyObject * obj2 = 0 ;
38347 PyObject * obj3 = 0 ;
38348 PyObject * obj4 = 0 ;
38349 PyObject * obj5 = 0 ;
38350 PyObject * obj6 = 0 ;
38351 char *kwnames[] = {
38352 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38353 };
38354
38355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38357 if (SWIG_arg_fail(1)) SWIG_fail;
38358 {
38359 arg2 = (int)(SWIG_As_int(obj1));
38360 if (SWIG_arg_fail(2)) SWIG_fail;
38361 }
38362 arg3 = obj2;
38363 if (obj3) {
38364 {
38365 arg4 = (int)(SWIG_As_int(obj3));
38366 if (SWIG_arg_fail(4)) SWIG_fail;
38367 }
38368 }
38369 if (obj4) {
38370 {
38371 arg5 = (int)(SWIG_As_int(obj4));
38372 if (SWIG_arg_fail(5)) SWIG_fail;
38373 }
38374 }
38375 if (obj5) {
38376 {
38377 arg6 = (int)(SWIG_As_int(obj5));
38378 if (SWIG_arg_fail(6)) SWIG_fail;
38379 }
38380 }
38381 if (obj6) {
38382 arg7 = obj6;
38383 }
38384 {
38385 PyThreadState* __tstate = wxPyBeginAllowThreads();
38386 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
38387
38388 wxPyEndAllowThreads(__tstate);
38389 if (PyErr_Occurred()) SWIG_fail;
38390 }
38391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38392 return resultobj;
38393 fail:
38394 return NULL;
38395 }
38396
38397
38398 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
38399 PyObject *resultobj;
38400 wxSizer *arg1 = (wxSizer *) 0 ;
38401 PyObject *arg2 = (PyObject *) 0 ;
38402 int arg3 = (int) 0 ;
38403 int arg4 = (int) 0 ;
38404 int arg5 = (int) 0 ;
38405 PyObject *arg6 = (PyObject *) NULL ;
38406 wxSizerItem *result;
38407 PyObject * obj0 = 0 ;
38408 PyObject * obj1 = 0 ;
38409 PyObject * obj2 = 0 ;
38410 PyObject * obj3 = 0 ;
38411 PyObject * obj4 = 0 ;
38412 PyObject * obj5 = 0 ;
38413 char *kwnames[] = {
38414 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38415 };
38416
38417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38419 if (SWIG_arg_fail(1)) SWIG_fail;
38420 arg2 = obj1;
38421 if (obj2) {
38422 {
38423 arg3 = (int)(SWIG_As_int(obj2));
38424 if (SWIG_arg_fail(3)) SWIG_fail;
38425 }
38426 }
38427 if (obj3) {
38428 {
38429 arg4 = (int)(SWIG_As_int(obj3));
38430 if (SWIG_arg_fail(4)) SWIG_fail;
38431 }
38432 }
38433 if (obj4) {
38434 {
38435 arg5 = (int)(SWIG_As_int(obj4));
38436 if (SWIG_arg_fail(5)) SWIG_fail;
38437 }
38438 }
38439 if (obj5) {
38440 arg6 = obj5;
38441 }
38442 {
38443 PyThreadState* __tstate = wxPyBeginAllowThreads();
38444 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
38445
38446 wxPyEndAllowThreads(__tstate);
38447 if (PyErr_Occurred()) SWIG_fail;
38448 }
38449 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38450 return resultobj;
38451 fail:
38452 return NULL;
38453 }
38454
38455
38456 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
38457 PyObject *resultobj;
38458 wxSizer *arg1 = (wxSizer *) 0 ;
38459 PyObject *arg2 = (PyObject *) 0 ;
38460 bool result;
38461 PyObject * obj0 = 0 ;
38462 PyObject * obj1 = 0 ;
38463 char *kwnames[] = {
38464 (char *) "self",(char *) "item", NULL
38465 };
38466
38467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
38468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38469 if (SWIG_arg_fail(1)) SWIG_fail;
38470 arg2 = obj1;
38471 {
38472 PyThreadState* __tstate = wxPyBeginAllowThreads();
38473 result = (bool)wxSizer_Remove(arg1,arg2);
38474
38475 wxPyEndAllowThreads(__tstate);
38476 if (PyErr_Occurred()) SWIG_fail;
38477 }
38478 {
38479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38480 }
38481 return resultobj;
38482 fail:
38483 return NULL;
38484 }
38485
38486
38487 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
38488 PyObject *resultobj;
38489 wxSizer *arg1 = (wxSizer *) 0 ;
38490 PyObject *arg2 = (PyObject *) 0 ;
38491 bool result;
38492 PyObject * obj0 = 0 ;
38493 PyObject * obj1 = 0 ;
38494 char *kwnames[] = {
38495 (char *) "self",(char *) "item", NULL
38496 };
38497
38498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
38499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38500 if (SWIG_arg_fail(1)) SWIG_fail;
38501 arg2 = obj1;
38502 {
38503 PyThreadState* __tstate = wxPyBeginAllowThreads();
38504 result = (bool)wxSizer_Detach(arg1,arg2);
38505
38506 wxPyEndAllowThreads(__tstate);
38507 if (PyErr_Occurred()) SWIG_fail;
38508 }
38509 {
38510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38511 }
38512 return resultobj;
38513 fail:
38514 return NULL;
38515 }
38516
38517
38518 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
38519 PyObject *resultobj;
38520 wxSizer *arg1 = (wxSizer *) 0 ;
38521 PyObject *arg2 = (PyObject *) 0 ;
38522 wxSizerItem *result;
38523 PyObject * obj0 = 0 ;
38524 PyObject * obj1 = 0 ;
38525 char *kwnames[] = {
38526 (char *) "self",(char *) "item", NULL
38527 };
38528
38529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
38530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38531 if (SWIG_arg_fail(1)) SWIG_fail;
38532 arg2 = obj1;
38533 {
38534 PyThreadState* __tstate = wxPyBeginAllowThreads();
38535 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
38536
38537 wxPyEndAllowThreads(__tstate);
38538 if (PyErr_Occurred()) SWIG_fail;
38539 }
38540 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38541 return resultobj;
38542 fail:
38543 return NULL;
38544 }
38545
38546
38547 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38548 PyObject *resultobj;
38549 wxSizer *arg1 = (wxSizer *) 0 ;
38550 PyObject *arg2 = (PyObject *) 0 ;
38551 wxSize *arg3 = 0 ;
38552 wxSize temp3 ;
38553 PyObject * obj0 = 0 ;
38554 PyObject * obj1 = 0 ;
38555 PyObject * obj2 = 0 ;
38556 char *kwnames[] = {
38557 (char *) "self",(char *) "item",(char *) "size", NULL
38558 };
38559
38560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38562 if (SWIG_arg_fail(1)) SWIG_fail;
38563 arg2 = obj1;
38564 {
38565 arg3 = &temp3;
38566 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
38567 }
38568 {
38569 PyThreadState* __tstate = wxPyBeginAllowThreads();
38570 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
38571
38572 wxPyEndAllowThreads(__tstate);
38573 if (PyErr_Occurred()) SWIG_fail;
38574 }
38575 Py_INCREF(Py_None); resultobj = Py_None;
38576 return resultobj;
38577 fail:
38578 return NULL;
38579 }
38580
38581
38582 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
38583 PyObject *resultobj;
38584 wxSizer *arg1 = (wxSizer *) 0 ;
38585 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
38586 wxSizerItem *result;
38587 PyObject * obj0 = 0 ;
38588 PyObject * obj1 = 0 ;
38589 char *kwnames[] = {
38590 (char *) "self",(char *) "item", NULL
38591 };
38592
38593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
38594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38595 if (SWIG_arg_fail(1)) SWIG_fail;
38596 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38597 if (SWIG_arg_fail(2)) SWIG_fail;
38598 {
38599 PyThreadState* __tstate = wxPyBeginAllowThreads();
38600 result = (wxSizerItem *)(arg1)->Add(arg2);
38601
38602 wxPyEndAllowThreads(__tstate);
38603 if (PyErr_Occurred()) SWIG_fail;
38604 }
38605 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38606 return resultobj;
38607 fail:
38608 return NULL;
38609 }
38610
38611
38612 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
38613 PyObject *resultobj;
38614 wxSizer *arg1 = (wxSizer *) 0 ;
38615 size_t arg2 ;
38616 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
38617 wxSizerItem *result;
38618 PyObject * obj0 = 0 ;
38619 PyObject * obj1 = 0 ;
38620 PyObject * obj2 = 0 ;
38621 char *kwnames[] = {
38622 (char *) "self",(char *) "index",(char *) "item", NULL
38623 };
38624
38625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
38626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38627 if (SWIG_arg_fail(1)) SWIG_fail;
38628 {
38629 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
38630 if (SWIG_arg_fail(2)) SWIG_fail;
38631 }
38632 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38633 if (SWIG_arg_fail(3)) SWIG_fail;
38634 {
38635 PyThreadState* __tstate = wxPyBeginAllowThreads();
38636 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
38637
38638 wxPyEndAllowThreads(__tstate);
38639 if (PyErr_Occurred()) SWIG_fail;
38640 }
38641 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38642 return resultobj;
38643 fail:
38644 return NULL;
38645 }
38646
38647
38648 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
38649 PyObject *resultobj;
38650 wxSizer *arg1 = (wxSizer *) 0 ;
38651 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
38652 wxSizerItem *result;
38653 PyObject * obj0 = 0 ;
38654 PyObject * obj1 = 0 ;
38655 char *kwnames[] = {
38656 (char *) "self",(char *) "item", NULL
38657 };
38658
38659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
38660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38661 if (SWIG_arg_fail(1)) SWIG_fail;
38662 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38663 if (SWIG_arg_fail(2)) SWIG_fail;
38664 {
38665 PyThreadState* __tstate = wxPyBeginAllowThreads();
38666 result = (wxSizerItem *)(arg1)->Prepend(arg2);
38667
38668 wxPyEndAllowThreads(__tstate);
38669 if (PyErr_Occurred()) SWIG_fail;
38670 }
38671 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38672 return resultobj;
38673 fail:
38674 return NULL;
38675 }
38676
38677
38678 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38679 PyObject *resultobj;
38680 wxSizer *arg1 = (wxSizer *) 0 ;
38681 int arg2 ;
38682 int arg3 ;
38683 int arg4 ;
38684 int arg5 ;
38685 PyObject * obj0 = 0 ;
38686 PyObject * obj1 = 0 ;
38687 PyObject * obj2 = 0 ;
38688 PyObject * obj3 = 0 ;
38689 PyObject * obj4 = 0 ;
38690 char *kwnames[] = {
38691 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
38692 };
38693
38694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38696 if (SWIG_arg_fail(1)) SWIG_fail;
38697 {
38698 arg2 = (int)(SWIG_As_int(obj1));
38699 if (SWIG_arg_fail(2)) SWIG_fail;
38700 }
38701 {
38702 arg3 = (int)(SWIG_As_int(obj2));
38703 if (SWIG_arg_fail(3)) SWIG_fail;
38704 }
38705 {
38706 arg4 = (int)(SWIG_As_int(obj3));
38707 if (SWIG_arg_fail(4)) SWIG_fail;
38708 }
38709 {
38710 arg5 = (int)(SWIG_As_int(obj4));
38711 if (SWIG_arg_fail(5)) SWIG_fail;
38712 }
38713 {
38714 PyThreadState* __tstate = wxPyBeginAllowThreads();
38715 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
38716
38717 wxPyEndAllowThreads(__tstate);
38718 if (PyErr_Occurred()) SWIG_fail;
38719 }
38720 Py_INCREF(Py_None); resultobj = Py_None;
38721 return resultobj;
38722 fail:
38723 return NULL;
38724 }
38725
38726
38727 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38728 PyObject *resultobj;
38729 wxSizer *arg1 = (wxSizer *) 0 ;
38730 wxSize *arg2 = 0 ;
38731 wxSize temp2 ;
38732 PyObject * obj0 = 0 ;
38733 PyObject * obj1 = 0 ;
38734 char *kwnames[] = {
38735 (char *) "self",(char *) "size", NULL
38736 };
38737
38738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
38739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38740 if (SWIG_arg_fail(1)) SWIG_fail;
38741 {
38742 arg2 = &temp2;
38743 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38744 }
38745 {
38746 PyThreadState* __tstate = wxPyBeginAllowThreads();
38747 (arg1)->SetMinSize((wxSize const &)*arg2);
38748
38749 wxPyEndAllowThreads(__tstate);
38750 if (PyErr_Occurred()) SWIG_fail;
38751 }
38752 Py_INCREF(Py_None); resultobj = Py_None;
38753 return resultobj;
38754 fail:
38755 return NULL;
38756 }
38757
38758
38759 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38760 PyObject *resultobj;
38761 wxSizer *arg1 = (wxSizer *) 0 ;
38762 wxSize result;
38763 PyObject * obj0 = 0 ;
38764 char *kwnames[] = {
38765 (char *) "self", NULL
38766 };
38767
38768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
38769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38770 if (SWIG_arg_fail(1)) SWIG_fail;
38771 {
38772 PyThreadState* __tstate = wxPyBeginAllowThreads();
38773 result = (arg1)->GetSize();
38774
38775 wxPyEndAllowThreads(__tstate);
38776 if (PyErr_Occurred()) SWIG_fail;
38777 }
38778 {
38779 wxSize * resultptr;
38780 resultptr = new wxSize((wxSize &)(result));
38781 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38782 }
38783 return resultobj;
38784 fail:
38785 return NULL;
38786 }
38787
38788
38789 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38790 PyObject *resultobj;
38791 wxSizer *arg1 = (wxSizer *) 0 ;
38792 wxPoint result;
38793 PyObject * obj0 = 0 ;
38794 char *kwnames[] = {
38795 (char *) "self", NULL
38796 };
38797
38798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
38799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38800 if (SWIG_arg_fail(1)) SWIG_fail;
38801 {
38802 PyThreadState* __tstate = wxPyBeginAllowThreads();
38803 result = (arg1)->GetPosition();
38804
38805 wxPyEndAllowThreads(__tstate);
38806 if (PyErr_Occurred()) SWIG_fail;
38807 }
38808 {
38809 wxPoint * resultptr;
38810 resultptr = new wxPoint((wxPoint &)(result));
38811 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38812 }
38813 return resultobj;
38814 fail:
38815 return NULL;
38816 }
38817
38818
38819 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38820 PyObject *resultobj;
38821 wxSizer *arg1 = (wxSizer *) 0 ;
38822 wxSize result;
38823 PyObject * obj0 = 0 ;
38824 char *kwnames[] = {
38825 (char *) "self", NULL
38826 };
38827
38828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
38829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38830 if (SWIG_arg_fail(1)) SWIG_fail;
38831 {
38832 PyThreadState* __tstate = wxPyBeginAllowThreads();
38833 result = (arg1)->GetMinSize();
38834
38835 wxPyEndAllowThreads(__tstate);
38836 if (PyErr_Occurred()) SWIG_fail;
38837 }
38838 {
38839 wxSize * resultptr;
38840 resultptr = new wxSize((wxSize &)(result));
38841 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38842 }
38843 return resultobj;
38844 fail:
38845 return NULL;
38846 }
38847
38848
38849 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
38850 PyObject *resultobj;
38851 wxSizer *arg1 = (wxSizer *) 0 ;
38852 PyObject * obj0 = 0 ;
38853 char *kwnames[] = {
38854 (char *) "self", NULL
38855 };
38856
38857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
38858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38859 if (SWIG_arg_fail(1)) SWIG_fail;
38860 {
38861 PyThreadState* __tstate = wxPyBeginAllowThreads();
38862 (arg1)->RecalcSizes();
38863
38864 wxPyEndAllowThreads(__tstate);
38865 if (PyErr_Occurred()) SWIG_fail;
38866 }
38867 Py_INCREF(Py_None); resultobj = Py_None;
38868 return resultobj;
38869 fail:
38870 return NULL;
38871 }
38872
38873
38874 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38875 PyObject *resultobj;
38876 wxSizer *arg1 = (wxSizer *) 0 ;
38877 wxSize result;
38878 PyObject * obj0 = 0 ;
38879 char *kwnames[] = {
38880 (char *) "self", NULL
38881 };
38882
38883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
38884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38885 if (SWIG_arg_fail(1)) SWIG_fail;
38886 {
38887 PyThreadState* __tstate = wxPyBeginAllowThreads();
38888 result = (arg1)->CalcMin();
38889
38890 wxPyEndAllowThreads(__tstate);
38891 if (PyErr_Occurred()) SWIG_fail;
38892 }
38893 {
38894 wxSize * resultptr;
38895 resultptr = new wxSize((wxSize &)(result));
38896 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38897 }
38898 return resultobj;
38899 fail:
38900 return NULL;
38901 }
38902
38903
38904 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
38905 PyObject *resultobj;
38906 wxSizer *arg1 = (wxSizer *) 0 ;
38907 PyObject * obj0 = 0 ;
38908 char *kwnames[] = {
38909 (char *) "self", NULL
38910 };
38911
38912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
38913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38914 if (SWIG_arg_fail(1)) SWIG_fail;
38915 {
38916 PyThreadState* __tstate = wxPyBeginAllowThreads();
38917 (arg1)->Layout();
38918
38919 wxPyEndAllowThreads(__tstate);
38920 if (PyErr_Occurred()) SWIG_fail;
38921 }
38922 Py_INCREF(Py_None); resultobj = Py_None;
38923 return resultobj;
38924 fail:
38925 return NULL;
38926 }
38927
38928
38929 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
38930 PyObject *resultobj;
38931 wxSizer *arg1 = (wxSizer *) 0 ;
38932 wxWindow *arg2 = (wxWindow *) 0 ;
38933 wxSize result;
38934 PyObject * obj0 = 0 ;
38935 PyObject * obj1 = 0 ;
38936 char *kwnames[] = {
38937 (char *) "self",(char *) "window", NULL
38938 };
38939
38940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
38941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38942 if (SWIG_arg_fail(1)) SWIG_fail;
38943 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38944 if (SWIG_arg_fail(2)) SWIG_fail;
38945 {
38946 PyThreadState* __tstate = wxPyBeginAllowThreads();
38947 result = (arg1)->Fit(arg2);
38948
38949 wxPyEndAllowThreads(__tstate);
38950 if (PyErr_Occurred()) SWIG_fail;
38951 }
38952 {
38953 wxSize * resultptr;
38954 resultptr = new wxSize((wxSize &)(result));
38955 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38956 }
38957 return resultobj;
38958 fail:
38959 return NULL;
38960 }
38961
38962
38963 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
38964 PyObject *resultobj;
38965 wxSizer *arg1 = (wxSizer *) 0 ;
38966 wxWindow *arg2 = (wxWindow *) 0 ;
38967 PyObject * obj0 = 0 ;
38968 PyObject * obj1 = 0 ;
38969 char *kwnames[] = {
38970 (char *) "self",(char *) "window", NULL
38971 };
38972
38973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
38974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38975 if (SWIG_arg_fail(1)) SWIG_fail;
38976 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38977 if (SWIG_arg_fail(2)) SWIG_fail;
38978 {
38979 PyThreadState* __tstate = wxPyBeginAllowThreads();
38980 (arg1)->FitInside(arg2);
38981
38982 wxPyEndAllowThreads(__tstate);
38983 if (PyErr_Occurred()) SWIG_fail;
38984 }
38985 Py_INCREF(Py_None); resultobj = Py_None;
38986 return resultobj;
38987 fail:
38988 return NULL;
38989 }
38990
38991
38992 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
38993 PyObject *resultobj;
38994 wxSizer *arg1 = (wxSizer *) 0 ;
38995 wxWindow *arg2 = (wxWindow *) 0 ;
38996 PyObject * obj0 = 0 ;
38997 PyObject * obj1 = 0 ;
38998 char *kwnames[] = {
38999 (char *) "self",(char *) "window", NULL
39000 };
39001
39002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
39003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39004 if (SWIG_arg_fail(1)) SWIG_fail;
39005 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39006 if (SWIG_arg_fail(2)) SWIG_fail;
39007 {
39008 PyThreadState* __tstate = wxPyBeginAllowThreads();
39009 (arg1)->SetSizeHints(arg2);
39010
39011 wxPyEndAllowThreads(__tstate);
39012 if (PyErr_Occurred()) SWIG_fail;
39013 }
39014 Py_INCREF(Py_None); resultobj = Py_None;
39015 return resultobj;
39016 fail:
39017 return NULL;
39018 }
39019
39020
39021 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39022 PyObject *resultobj;
39023 wxSizer *arg1 = (wxSizer *) 0 ;
39024 wxWindow *arg2 = (wxWindow *) 0 ;
39025 PyObject * obj0 = 0 ;
39026 PyObject * obj1 = 0 ;
39027 char *kwnames[] = {
39028 (char *) "self",(char *) "window", NULL
39029 };
39030
39031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
39032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39033 if (SWIG_arg_fail(1)) SWIG_fail;
39034 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39035 if (SWIG_arg_fail(2)) SWIG_fail;
39036 {
39037 PyThreadState* __tstate = wxPyBeginAllowThreads();
39038 (arg1)->SetVirtualSizeHints(arg2);
39039
39040 wxPyEndAllowThreads(__tstate);
39041 if (PyErr_Occurred()) SWIG_fail;
39042 }
39043 Py_INCREF(Py_None); resultobj = Py_None;
39044 return resultobj;
39045 fail:
39046 return NULL;
39047 }
39048
39049
39050 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
39051 PyObject *resultobj;
39052 wxSizer *arg1 = (wxSizer *) 0 ;
39053 bool arg2 = (bool) false ;
39054 PyObject * obj0 = 0 ;
39055 PyObject * obj1 = 0 ;
39056 char *kwnames[] = {
39057 (char *) "self",(char *) "deleteWindows", NULL
39058 };
39059
39060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
39061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39062 if (SWIG_arg_fail(1)) SWIG_fail;
39063 if (obj1) {
39064 {
39065 arg2 = (bool)(SWIG_As_bool(obj1));
39066 if (SWIG_arg_fail(2)) SWIG_fail;
39067 }
39068 }
39069 {
39070 PyThreadState* __tstate = wxPyBeginAllowThreads();
39071 (arg1)->Clear(arg2);
39072
39073 wxPyEndAllowThreads(__tstate);
39074 if (PyErr_Occurred()) SWIG_fail;
39075 }
39076 Py_INCREF(Py_None); resultobj = Py_None;
39077 return resultobj;
39078 fail:
39079 return NULL;
39080 }
39081
39082
39083 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39084 PyObject *resultobj;
39085 wxSizer *arg1 = (wxSizer *) 0 ;
39086 PyObject * obj0 = 0 ;
39087 char *kwnames[] = {
39088 (char *) "self", NULL
39089 };
39090
39091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
39092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39093 if (SWIG_arg_fail(1)) SWIG_fail;
39094 {
39095 PyThreadState* __tstate = wxPyBeginAllowThreads();
39096 (arg1)->DeleteWindows();
39097
39098 wxPyEndAllowThreads(__tstate);
39099 if (PyErr_Occurred()) SWIG_fail;
39100 }
39101 Py_INCREF(Py_None); resultobj = Py_None;
39102 return resultobj;
39103 fail:
39104 return NULL;
39105 }
39106
39107
39108 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
39109 PyObject *resultobj;
39110 wxSizer *arg1 = (wxSizer *) 0 ;
39111 PyObject *result;
39112 PyObject * obj0 = 0 ;
39113 char *kwnames[] = {
39114 (char *) "self", NULL
39115 };
39116
39117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
39118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39119 if (SWIG_arg_fail(1)) SWIG_fail;
39120 {
39121 PyThreadState* __tstate = wxPyBeginAllowThreads();
39122 result = (PyObject *)wxSizer_GetChildren(arg1);
39123
39124 wxPyEndAllowThreads(__tstate);
39125 if (PyErr_Occurred()) SWIG_fail;
39126 }
39127 resultobj = result;
39128 return resultobj;
39129 fail:
39130 return NULL;
39131 }
39132
39133
39134 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39135 PyObject *resultobj;
39136 wxSizer *arg1 = (wxSizer *) 0 ;
39137 PyObject *arg2 = (PyObject *) 0 ;
39138 bool arg3 = (bool) true ;
39139 bool arg4 = (bool) false ;
39140 bool result;
39141 PyObject * obj0 = 0 ;
39142 PyObject * obj1 = 0 ;
39143 PyObject * obj2 = 0 ;
39144 PyObject * obj3 = 0 ;
39145 char *kwnames[] = {
39146 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
39147 };
39148
39149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39151 if (SWIG_arg_fail(1)) SWIG_fail;
39152 arg2 = obj1;
39153 if (obj2) {
39154 {
39155 arg3 = (bool)(SWIG_As_bool(obj2));
39156 if (SWIG_arg_fail(3)) SWIG_fail;
39157 }
39158 }
39159 if (obj3) {
39160 {
39161 arg4 = (bool)(SWIG_As_bool(obj3));
39162 if (SWIG_arg_fail(4)) SWIG_fail;
39163 }
39164 }
39165 {
39166 PyThreadState* __tstate = wxPyBeginAllowThreads();
39167 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
39168
39169 wxPyEndAllowThreads(__tstate);
39170 if (PyErr_Occurred()) SWIG_fail;
39171 }
39172 {
39173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39174 }
39175 return resultobj;
39176 fail:
39177 return NULL;
39178 }
39179
39180
39181 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39182 PyObject *resultobj;
39183 wxSizer *arg1 = (wxSizer *) 0 ;
39184 PyObject *arg2 = (PyObject *) 0 ;
39185 bool result;
39186 PyObject * obj0 = 0 ;
39187 PyObject * obj1 = 0 ;
39188 char *kwnames[] = {
39189 (char *) "self",(char *) "item", NULL
39190 };
39191
39192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
39193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39194 if (SWIG_arg_fail(1)) SWIG_fail;
39195 arg2 = obj1;
39196 {
39197 PyThreadState* __tstate = wxPyBeginAllowThreads();
39198 result = (bool)wxSizer_IsShown(arg1,arg2);
39199
39200 wxPyEndAllowThreads(__tstate);
39201 if (PyErr_Occurred()) SWIG_fail;
39202 }
39203 {
39204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39205 }
39206 return resultobj;
39207 fail:
39208 return NULL;
39209 }
39210
39211
39212 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
39213 PyObject *resultobj;
39214 wxSizer *arg1 = (wxSizer *) 0 ;
39215 bool arg2 ;
39216 PyObject * obj0 = 0 ;
39217 PyObject * obj1 = 0 ;
39218 char *kwnames[] = {
39219 (char *) "self",(char *) "show", NULL
39220 };
39221
39222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
39223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39224 if (SWIG_arg_fail(1)) SWIG_fail;
39225 {
39226 arg2 = (bool)(SWIG_As_bool(obj1));
39227 if (SWIG_arg_fail(2)) SWIG_fail;
39228 }
39229 {
39230 PyThreadState* __tstate = wxPyBeginAllowThreads();
39231 (arg1)->ShowItems(arg2);
39232
39233 wxPyEndAllowThreads(__tstate);
39234 if (PyErr_Occurred()) SWIG_fail;
39235 }
39236 Py_INCREF(Py_None); resultobj = Py_None;
39237 return resultobj;
39238 fail:
39239 return NULL;
39240 }
39241
39242
39243 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
39244 PyObject *obj;
39245 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39246 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
39247 Py_INCREF(obj);
39248 return Py_BuildValue((char *)"");
39249 }
39250 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
39251 PyObject *resultobj;
39252 wxPySizer *result;
39253 char *kwnames[] = {
39254 NULL
39255 };
39256
39257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
39258 {
39259 PyThreadState* __tstate = wxPyBeginAllowThreads();
39260 result = (wxPySizer *)new wxPySizer();
39261
39262 wxPyEndAllowThreads(__tstate);
39263 if (PyErr_Occurred()) SWIG_fail;
39264 }
39265 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
39266 return resultobj;
39267 fail:
39268 return NULL;
39269 }
39270
39271
39272 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39273 PyObject *resultobj;
39274 wxPySizer *arg1 = (wxPySizer *) 0 ;
39275 PyObject *arg2 = (PyObject *) 0 ;
39276 PyObject *arg3 = (PyObject *) 0 ;
39277 PyObject * obj0 = 0 ;
39278 PyObject * obj1 = 0 ;
39279 PyObject * obj2 = 0 ;
39280 char *kwnames[] = {
39281 (char *) "self",(char *) "self",(char *) "_class", NULL
39282 };
39283
39284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
39285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
39286 if (SWIG_arg_fail(1)) SWIG_fail;
39287 arg2 = obj1;
39288 arg3 = obj2;
39289 {
39290 PyThreadState* __tstate = wxPyBeginAllowThreads();
39291 (arg1)->_setCallbackInfo(arg2,arg3);
39292
39293 wxPyEndAllowThreads(__tstate);
39294 if (PyErr_Occurred()) SWIG_fail;
39295 }
39296 Py_INCREF(Py_None); resultobj = Py_None;
39297 return resultobj;
39298 fail:
39299 return NULL;
39300 }
39301
39302
39303 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
39304 PyObject *obj;
39305 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39306 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
39307 Py_INCREF(obj);
39308 return Py_BuildValue((char *)"");
39309 }
39310 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39311 PyObject *resultobj;
39312 int arg1 = (int) wxHORIZONTAL ;
39313 wxBoxSizer *result;
39314 PyObject * obj0 = 0 ;
39315 char *kwnames[] = {
39316 (char *) "orient", NULL
39317 };
39318
39319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
39320 if (obj0) {
39321 {
39322 arg1 = (int)(SWIG_As_int(obj0));
39323 if (SWIG_arg_fail(1)) SWIG_fail;
39324 }
39325 }
39326 {
39327 PyThreadState* __tstate = wxPyBeginAllowThreads();
39328 result = (wxBoxSizer *)new wxBoxSizer(arg1);
39329
39330 wxPyEndAllowThreads(__tstate);
39331 if (PyErr_Occurred()) SWIG_fail;
39332 }
39333 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
39334 return resultobj;
39335 fail:
39336 return NULL;
39337 }
39338
39339
39340 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
39341 PyObject *resultobj;
39342 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
39343 int result;
39344 PyObject * obj0 = 0 ;
39345 char *kwnames[] = {
39346 (char *) "self", NULL
39347 };
39348
39349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
39350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39351 if (SWIG_arg_fail(1)) SWIG_fail;
39352 {
39353 PyThreadState* __tstate = wxPyBeginAllowThreads();
39354 result = (int)(arg1)->GetOrientation();
39355
39356 wxPyEndAllowThreads(__tstate);
39357 if (PyErr_Occurred()) SWIG_fail;
39358 }
39359 {
39360 resultobj = SWIG_From_int((int)(result));
39361 }
39362 return resultobj;
39363 fail:
39364 return NULL;
39365 }
39366
39367
39368 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
39369 PyObject *resultobj;
39370 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
39371 int arg2 ;
39372 PyObject * obj0 = 0 ;
39373 PyObject * obj1 = 0 ;
39374 char *kwnames[] = {
39375 (char *) "self",(char *) "orient", NULL
39376 };
39377
39378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
39379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39380 if (SWIG_arg_fail(1)) SWIG_fail;
39381 {
39382 arg2 = (int)(SWIG_As_int(obj1));
39383 if (SWIG_arg_fail(2)) SWIG_fail;
39384 }
39385 {
39386 PyThreadState* __tstate = wxPyBeginAllowThreads();
39387 (arg1)->SetOrientation(arg2);
39388
39389 wxPyEndAllowThreads(__tstate);
39390 if (PyErr_Occurred()) SWIG_fail;
39391 }
39392 Py_INCREF(Py_None); resultobj = Py_None;
39393 return resultobj;
39394 fail:
39395 return NULL;
39396 }
39397
39398
39399 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
39400 PyObject *obj;
39401 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39402 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
39403 Py_INCREF(obj);
39404 return Py_BuildValue((char *)"");
39405 }
39406 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39407 PyObject *resultobj;
39408 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
39409 int arg2 = (int) wxHORIZONTAL ;
39410 wxStaticBoxSizer *result;
39411 PyObject * obj0 = 0 ;
39412 PyObject * obj1 = 0 ;
39413 char *kwnames[] = {
39414 (char *) "box",(char *) "orient", NULL
39415 };
39416
39417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
39418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
39419 if (SWIG_arg_fail(1)) SWIG_fail;
39420 if (obj1) {
39421 {
39422 arg2 = (int)(SWIG_As_int(obj1));
39423 if (SWIG_arg_fail(2)) SWIG_fail;
39424 }
39425 }
39426 {
39427 PyThreadState* __tstate = wxPyBeginAllowThreads();
39428 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
39429
39430 wxPyEndAllowThreads(__tstate);
39431 if (PyErr_Occurred()) SWIG_fail;
39432 }
39433 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
39434 return resultobj;
39435 fail:
39436 return NULL;
39437 }
39438
39439
39440 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
39441 PyObject *resultobj;
39442 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
39443 wxStaticBox *result;
39444 PyObject * obj0 = 0 ;
39445 char *kwnames[] = {
39446 (char *) "self", NULL
39447 };
39448
39449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
39450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39451 if (SWIG_arg_fail(1)) SWIG_fail;
39452 {
39453 PyThreadState* __tstate = wxPyBeginAllowThreads();
39454 result = (wxStaticBox *)(arg1)->GetStaticBox();
39455
39456 wxPyEndAllowThreads(__tstate);
39457 if (PyErr_Occurred()) SWIG_fail;
39458 }
39459 {
39460 resultobj = wxPyMake_wxObject(result, 0);
39461 }
39462 return resultobj;
39463 fail:
39464 return NULL;
39465 }
39466
39467
39468 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
39469 PyObject *obj;
39470 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39471 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
39472 Py_INCREF(obj);
39473 return Py_BuildValue((char *)"");
39474 }
39475 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39476 PyObject *resultobj;
39477 int arg1 = (int) 1 ;
39478 int arg2 = (int) 0 ;
39479 int arg3 = (int) 0 ;
39480 int arg4 = (int) 0 ;
39481 wxGridSizer *result;
39482 PyObject * obj0 = 0 ;
39483 PyObject * obj1 = 0 ;
39484 PyObject * obj2 = 0 ;
39485 PyObject * obj3 = 0 ;
39486 char *kwnames[] = {
39487 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
39488 };
39489
39490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39491 if (obj0) {
39492 {
39493 arg1 = (int)(SWIG_As_int(obj0));
39494 if (SWIG_arg_fail(1)) SWIG_fail;
39495 }
39496 }
39497 if (obj1) {
39498 {
39499 arg2 = (int)(SWIG_As_int(obj1));
39500 if (SWIG_arg_fail(2)) SWIG_fail;
39501 }
39502 }
39503 if (obj2) {
39504 {
39505 arg3 = (int)(SWIG_As_int(obj2));
39506 if (SWIG_arg_fail(3)) SWIG_fail;
39507 }
39508 }
39509 if (obj3) {
39510 {
39511 arg4 = (int)(SWIG_As_int(obj3));
39512 if (SWIG_arg_fail(4)) SWIG_fail;
39513 }
39514 }
39515 {
39516 PyThreadState* __tstate = wxPyBeginAllowThreads();
39517 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
39518
39519 wxPyEndAllowThreads(__tstate);
39520 if (PyErr_Occurred()) SWIG_fail;
39521 }
39522 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
39523 return resultobj;
39524 fail:
39525 return NULL;
39526 }
39527
39528
39529 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
39530 PyObject *resultobj;
39531 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39532 int arg2 ;
39533 PyObject * obj0 = 0 ;
39534 PyObject * obj1 = 0 ;
39535 char *kwnames[] = {
39536 (char *) "self",(char *) "cols", NULL
39537 };
39538
39539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
39540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39541 if (SWIG_arg_fail(1)) SWIG_fail;
39542 {
39543 arg2 = (int)(SWIG_As_int(obj1));
39544 if (SWIG_arg_fail(2)) SWIG_fail;
39545 }
39546 {
39547 PyThreadState* __tstate = wxPyBeginAllowThreads();
39548 (arg1)->SetCols(arg2);
39549
39550 wxPyEndAllowThreads(__tstate);
39551 if (PyErr_Occurred()) SWIG_fail;
39552 }
39553 Py_INCREF(Py_None); resultobj = Py_None;
39554 return resultobj;
39555 fail:
39556 return NULL;
39557 }
39558
39559
39560 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
39561 PyObject *resultobj;
39562 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39563 int arg2 ;
39564 PyObject * obj0 = 0 ;
39565 PyObject * obj1 = 0 ;
39566 char *kwnames[] = {
39567 (char *) "self",(char *) "rows", NULL
39568 };
39569
39570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
39571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39572 if (SWIG_arg_fail(1)) SWIG_fail;
39573 {
39574 arg2 = (int)(SWIG_As_int(obj1));
39575 if (SWIG_arg_fail(2)) SWIG_fail;
39576 }
39577 {
39578 PyThreadState* __tstate = wxPyBeginAllowThreads();
39579 (arg1)->SetRows(arg2);
39580
39581 wxPyEndAllowThreads(__tstate);
39582 if (PyErr_Occurred()) SWIG_fail;
39583 }
39584 Py_INCREF(Py_None); resultobj = Py_None;
39585 return resultobj;
39586 fail:
39587 return NULL;
39588 }
39589
39590
39591 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
39592 PyObject *resultobj;
39593 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39594 int arg2 ;
39595 PyObject * obj0 = 0 ;
39596 PyObject * obj1 = 0 ;
39597 char *kwnames[] = {
39598 (char *) "self",(char *) "gap", NULL
39599 };
39600
39601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
39602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39603 if (SWIG_arg_fail(1)) SWIG_fail;
39604 {
39605 arg2 = (int)(SWIG_As_int(obj1));
39606 if (SWIG_arg_fail(2)) SWIG_fail;
39607 }
39608 {
39609 PyThreadState* __tstate = wxPyBeginAllowThreads();
39610 (arg1)->SetVGap(arg2);
39611
39612 wxPyEndAllowThreads(__tstate);
39613 if (PyErr_Occurred()) SWIG_fail;
39614 }
39615 Py_INCREF(Py_None); resultobj = Py_None;
39616 return resultobj;
39617 fail:
39618 return NULL;
39619 }
39620
39621
39622 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
39623 PyObject *resultobj;
39624 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39625 int arg2 ;
39626 PyObject * obj0 = 0 ;
39627 PyObject * obj1 = 0 ;
39628 char *kwnames[] = {
39629 (char *) "self",(char *) "gap", NULL
39630 };
39631
39632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
39633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39634 if (SWIG_arg_fail(1)) SWIG_fail;
39635 {
39636 arg2 = (int)(SWIG_As_int(obj1));
39637 if (SWIG_arg_fail(2)) SWIG_fail;
39638 }
39639 {
39640 PyThreadState* __tstate = wxPyBeginAllowThreads();
39641 (arg1)->SetHGap(arg2);
39642
39643 wxPyEndAllowThreads(__tstate);
39644 if (PyErr_Occurred()) SWIG_fail;
39645 }
39646 Py_INCREF(Py_None); resultobj = Py_None;
39647 return resultobj;
39648 fail:
39649 return NULL;
39650 }
39651
39652
39653 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
39654 PyObject *resultobj;
39655 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39656 int result;
39657 PyObject * obj0 = 0 ;
39658 char *kwnames[] = {
39659 (char *) "self", NULL
39660 };
39661
39662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
39663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39664 if (SWIG_arg_fail(1)) SWIG_fail;
39665 {
39666 PyThreadState* __tstate = wxPyBeginAllowThreads();
39667 result = (int)(arg1)->GetCols();
39668
39669 wxPyEndAllowThreads(__tstate);
39670 if (PyErr_Occurred()) SWIG_fail;
39671 }
39672 {
39673 resultobj = SWIG_From_int((int)(result));
39674 }
39675 return resultobj;
39676 fail:
39677 return NULL;
39678 }
39679
39680
39681 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
39682 PyObject *resultobj;
39683 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39684 int result;
39685 PyObject * obj0 = 0 ;
39686 char *kwnames[] = {
39687 (char *) "self", NULL
39688 };
39689
39690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
39691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39692 if (SWIG_arg_fail(1)) SWIG_fail;
39693 {
39694 PyThreadState* __tstate = wxPyBeginAllowThreads();
39695 result = (int)(arg1)->GetRows();
39696
39697 wxPyEndAllowThreads(__tstate);
39698 if (PyErr_Occurred()) SWIG_fail;
39699 }
39700 {
39701 resultobj = SWIG_From_int((int)(result));
39702 }
39703 return resultobj;
39704 fail:
39705 return NULL;
39706 }
39707
39708
39709 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
39710 PyObject *resultobj;
39711 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39712 int result;
39713 PyObject * obj0 = 0 ;
39714 char *kwnames[] = {
39715 (char *) "self", NULL
39716 };
39717
39718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
39719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39720 if (SWIG_arg_fail(1)) SWIG_fail;
39721 {
39722 PyThreadState* __tstate = wxPyBeginAllowThreads();
39723 result = (int)(arg1)->GetVGap();
39724
39725 wxPyEndAllowThreads(__tstate);
39726 if (PyErr_Occurred()) SWIG_fail;
39727 }
39728 {
39729 resultobj = SWIG_From_int((int)(result));
39730 }
39731 return resultobj;
39732 fail:
39733 return NULL;
39734 }
39735
39736
39737 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
39738 PyObject *resultobj;
39739 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39740 int result;
39741 PyObject * obj0 = 0 ;
39742 char *kwnames[] = {
39743 (char *) "self", NULL
39744 };
39745
39746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
39747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39748 if (SWIG_arg_fail(1)) SWIG_fail;
39749 {
39750 PyThreadState* __tstate = wxPyBeginAllowThreads();
39751 result = (int)(arg1)->GetHGap();
39752
39753 wxPyEndAllowThreads(__tstate);
39754 if (PyErr_Occurred()) SWIG_fail;
39755 }
39756 {
39757 resultobj = SWIG_From_int((int)(result));
39758 }
39759 return resultobj;
39760 fail:
39761 return NULL;
39762 }
39763
39764
39765 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
39766 PyObject *obj;
39767 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39768 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
39769 Py_INCREF(obj);
39770 return Py_BuildValue((char *)"");
39771 }
39772 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39773 PyObject *resultobj;
39774 int arg1 = (int) 1 ;
39775 int arg2 = (int) 0 ;
39776 int arg3 = (int) 0 ;
39777 int arg4 = (int) 0 ;
39778 wxFlexGridSizer *result;
39779 PyObject * obj0 = 0 ;
39780 PyObject * obj1 = 0 ;
39781 PyObject * obj2 = 0 ;
39782 PyObject * obj3 = 0 ;
39783 char *kwnames[] = {
39784 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
39785 };
39786
39787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39788 if (obj0) {
39789 {
39790 arg1 = (int)(SWIG_As_int(obj0));
39791 if (SWIG_arg_fail(1)) SWIG_fail;
39792 }
39793 }
39794 if (obj1) {
39795 {
39796 arg2 = (int)(SWIG_As_int(obj1));
39797 if (SWIG_arg_fail(2)) SWIG_fail;
39798 }
39799 }
39800 if (obj2) {
39801 {
39802 arg3 = (int)(SWIG_As_int(obj2));
39803 if (SWIG_arg_fail(3)) SWIG_fail;
39804 }
39805 }
39806 if (obj3) {
39807 {
39808 arg4 = (int)(SWIG_As_int(obj3));
39809 if (SWIG_arg_fail(4)) SWIG_fail;
39810 }
39811 }
39812 {
39813 PyThreadState* __tstate = wxPyBeginAllowThreads();
39814 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
39815
39816 wxPyEndAllowThreads(__tstate);
39817 if (PyErr_Occurred()) SWIG_fail;
39818 }
39819 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
39820 return resultobj;
39821 fail:
39822 return NULL;
39823 }
39824
39825
39826 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
39827 PyObject *resultobj;
39828 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39829 size_t arg2 ;
39830 int arg3 = (int) 0 ;
39831 PyObject * obj0 = 0 ;
39832 PyObject * obj1 = 0 ;
39833 PyObject * obj2 = 0 ;
39834 char *kwnames[] = {
39835 (char *) "self",(char *) "idx",(char *) "proportion", NULL
39836 };
39837
39838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
39839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39840 if (SWIG_arg_fail(1)) SWIG_fail;
39841 {
39842 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39843 if (SWIG_arg_fail(2)) SWIG_fail;
39844 }
39845 if (obj2) {
39846 {
39847 arg3 = (int)(SWIG_As_int(obj2));
39848 if (SWIG_arg_fail(3)) SWIG_fail;
39849 }
39850 }
39851 {
39852 PyThreadState* __tstate = wxPyBeginAllowThreads();
39853 (arg1)->AddGrowableRow(arg2,arg3);
39854
39855 wxPyEndAllowThreads(__tstate);
39856 if (PyErr_Occurred()) SWIG_fail;
39857 }
39858 Py_INCREF(Py_None); resultobj = Py_None;
39859 return resultobj;
39860 fail:
39861 return NULL;
39862 }
39863
39864
39865 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
39866 PyObject *resultobj;
39867 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39868 size_t arg2 ;
39869 PyObject * obj0 = 0 ;
39870 PyObject * obj1 = 0 ;
39871 char *kwnames[] = {
39872 (char *) "self",(char *) "idx", NULL
39873 };
39874
39875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
39876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39877 if (SWIG_arg_fail(1)) SWIG_fail;
39878 {
39879 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39880 if (SWIG_arg_fail(2)) SWIG_fail;
39881 }
39882 {
39883 PyThreadState* __tstate = wxPyBeginAllowThreads();
39884 (arg1)->RemoveGrowableRow(arg2);
39885
39886 wxPyEndAllowThreads(__tstate);
39887 if (PyErr_Occurred()) SWIG_fail;
39888 }
39889 Py_INCREF(Py_None); resultobj = Py_None;
39890 return resultobj;
39891 fail:
39892 return NULL;
39893 }
39894
39895
39896 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
39897 PyObject *resultobj;
39898 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39899 size_t arg2 ;
39900 int arg3 = (int) 0 ;
39901 PyObject * obj0 = 0 ;
39902 PyObject * obj1 = 0 ;
39903 PyObject * obj2 = 0 ;
39904 char *kwnames[] = {
39905 (char *) "self",(char *) "idx",(char *) "proportion", NULL
39906 };
39907
39908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
39909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39910 if (SWIG_arg_fail(1)) SWIG_fail;
39911 {
39912 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39913 if (SWIG_arg_fail(2)) SWIG_fail;
39914 }
39915 if (obj2) {
39916 {
39917 arg3 = (int)(SWIG_As_int(obj2));
39918 if (SWIG_arg_fail(3)) SWIG_fail;
39919 }
39920 }
39921 {
39922 PyThreadState* __tstate = wxPyBeginAllowThreads();
39923 (arg1)->AddGrowableCol(arg2,arg3);
39924
39925 wxPyEndAllowThreads(__tstate);
39926 if (PyErr_Occurred()) SWIG_fail;
39927 }
39928 Py_INCREF(Py_None); resultobj = Py_None;
39929 return resultobj;
39930 fail:
39931 return NULL;
39932 }
39933
39934
39935 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
39936 PyObject *resultobj;
39937 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39938 size_t arg2 ;
39939 PyObject * obj0 = 0 ;
39940 PyObject * obj1 = 0 ;
39941 char *kwnames[] = {
39942 (char *) "self",(char *) "idx", NULL
39943 };
39944
39945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
39946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39947 if (SWIG_arg_fail(1)) SWIG_fail;
39948 {
39949 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39950 if (SWIG_arg_fail(2)) SWIG_fail;
39951 }
39952 {
39953 PyThreadState* __tstate = wxPyBeginAllowThreads();
39954 (arg1)->RemoveGrowableCol(arg2);
39955
39956 wxPyEndAllowThreads(__tstate);
39957 if (PyErr_Occurred()) SWIG_fail;
39958 }
39959 Py_INCREF(Py_None); resultobj = Py_None;
39960 return resultobj;
39961 fail:
39962 return NULL;
39963 }
39964
39965
39966 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
39967 PyObject *resultobj;
39968 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39969 int arg2 ;
39970 PyObject * obj0 = 0 ;
39971 PyObject * obj1 = 0 ;
39972 char *kwnames[] = {
39973 (char *) "self",(char *) "direction", NULL
39974 };
39975
39976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
39977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39978 if (SWIG_arg_fail(1)) SWIG_fail;
39979 {
39980 arg2 = (int)(SWIG_As_int(obj1));
39981 if (SWIG_arg_fail(2)) SWIG_fail;
39982 }
39983 {
39984 PyThreadState* __tstate = wxPyBeginAllowThreads();
39985 (arg1)->SetFlexibleDirection(arg2);
39986
39987 wxPyEndAllowThreads(__tstate);
39988 if (PyErr_Occurred()) SWIG_fail;
39989 }
39990 Py_INCREF(Py_None); resultobj = Py_None;
39991 return resultobj;
39992 fail:
39993 return NULL;
39994 }
39995
39996
39997 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
39998 PyObject *resultobj;
39999 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40000 int result;
40001 PyObject * obj0 = 0 ;
40002 char *kwnames[] = {
40003 (char *) "self", NULL
40004 };
40005
40006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
40007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40008 if (SWIG_arg_fail(1)) SWIG_fail;
40009 {
40010 PyThreadState* __tstate = wxPyBeginAllowThreads();
40011 result = (int)(arg1)->GetFlexibleDirection();
40012
40013 wxPyEndAllowThreads(__tstate);
40014 if (PyErr_Occurred()) SWIG_fail;
40015 }
40016 {
40017 resultobj = SWIG_From_int((int)(result));
40018 }
40019 return resultobj;
40020 fail:
40021 return NULL;
40022 }
40023
40024
40025 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40026 PyObject *resultobj;
40027 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40028 wxFlexSizerGrowMode arg2 ;
40029 PyObject * obj0 = 0 ;
40030 PyObject * obj1 = 0 ;
40031 char *kwnames[] = {
40032 (char *) "self",(char *) "mode", NULL
40033 };
40034
40035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
40036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40037 if (SWIG_arg_fail(1)) SWIG_fail;
40038 {
40039 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
40040 if (SWIG_arg_fail(2)) SWIG_fail;
40041 }
40042 {
40043 PyThreadState* __tstate = wxPyBeginAllowThreads();
40044 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
40045
40046 wxPyEndAllowThreads(__tstate);
40047 if (PyErr_Occurred()) SWIG_fail;
40048 }
40049 Py_INCREF(Py_None); resultobj = Py_None;
40050 return resultobj;
40051 fail:
40052 return NULL;
40053 }
40054
40055
40056 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40057 PyObject *resultobj;
40058 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40059 wxFlexSizerGrowMode result;
40060 PyObject * obj0 = 0 ;
40061 char *kwnames[] = {
40062 (char *) "self", NULL
40063 };
40064
40065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
40066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40067 if (SWIG_arg_fail(1)) SWIG_fail;
40068 {
40069 PyThreadState* __tstate = wxPyBeginAllowThreads();
40070 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
40071
40072 wxPyEndAllowThreads(__tstate);
40073 if (PyErr_Occurred()) SWIG_fail;
40074 }
40075 resultobj = SWIG_From_int((result));
40076 return resultobj;
40077 fail:
40078 return NULL;
40079 }
40080
40081
40082 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
40083 PyObject *resultobj;
40084 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40085 wxArrayInt *result;
40086 PyObject * obj0 = 0 ;
40087 char *kwnames[] = {
40088 (char *) "self", NULL
40089 };
40090
40091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
40092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40093 if (SWIG_arg_fail(1)) SWIG_fail;
40094 {
40095 PyThreadState* __tstate = wxPyBeginAllowThreads();
40096 {
40097 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
40098 result = (wxArrayInt *) &_result_ref;
40099 }
40100
40101 wxPyEndAllowThreads(__tstate);
40102 if (PyErr_Occurred()) SWIG_fail;
40103 }
40104 {
40105 resultobj = PyList_New(0);
40106 size_t idx;
40107 for (idx = 0; idx < result->GetCount(); idx += 1) {
40108 PyObject* val = PyInt_FromLong( result->Item(idx) );
40109 PyList_Append(resultobj, val);
40110 Py_DECREF(val);
40111 }
40112 }
40113 return resultobj;
40114 fail:
40115 return NULL;
40116 }
40117
40118
40119 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
40120 PyObject *resultobj;
40121 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40122 wxArrayInt *result;
40123 PyObject * obj0 = 0 ;
40124 char *kwnames[] = {
40125 (char *) "self", NULL
40126 };
40127
40128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
40129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40130 if (SWIG_arg_fail(1)) SWIG_fail;
40131 {
40132 PyThreadState* __tstate = wxPyBeginAllowThreads();
40133 {
40134 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
40135 result = (wxArrayInt *) &_result_ref;
40136 }
40137
40138 wxPyEndAllowThreads(__tstate);
40139 if (PyErr_Occurred()) SWIG_fail;
40140 }
40141 {
40142 resultobj = PyList_New(0);
40143 size_t idx;
40144 for (idx = 0; idx < result->GetCount(); idx += 1) {
40145 PyObject* val = PyInt_FromLong( result->Item(idx) );
40146 PyList_Append(resultobj, val);
40147 Py_DECREF(val);
40148 }
40149 }
40150 return resultobj;
40151 fail:
40152 return NULL;
40153 }
40154
40155
40156 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
40157 PyObject *obj;
40158 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40159 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
40160 Py_INCREF(obj);
40161 return Py_BuildValue((char *)"");
40162 }
40163 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40164 PyObject *resultobj;
40165 wxStdDialogButtonSizer *result;
40166 char *kwnames[] = {
40167 NULL
40168 };
40169
40170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
40171 {
40172 PyThreadState* __tstate = wxPyBeginAllowThreads();
40173 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
40174
40175 wxPyEndAllowThreads(__tstate);
40176 if (PyErr_Occurred()) SWIG_fail;
40177 }
40178 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
40179 return resultobj;
40180 fail:
40181 return NULL;
40182 }
40183
40184
40185 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
40186 PyObject *resultobj;
40187 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40188 wxButton *arg2 = (wxButton *) 0 ;
40189 PyObject * obj0 = 0 ;
40190 PyObject * obj1 = 0 ;
40191 char *kwnames[] = {
40192 (char *) "self",(char *) "button", NULL
40193 };
40194
40195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
40196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40197 if (SWIG_arg_fail(1)) SWIG_fail;
40198 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40199 if (SWIG_arg_fail(2)) SWIG_fail;
40200 {
40201 PyThreadState* __tstate = wxPyBeginAllowThreads();
40202 (arg1)->AddButton(arg2);
40203
40204 wxPyEndAllowThreads(__tstate);
40205 if (PyErr_Occurred()) SWIG_fail;
40206 }
40207 Py_INCREF(Py_None); resultobj = Py_None;
40208 return resultobj;
40209 fail:
40210 return NULL;
40211 }
40212
40213
40214 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
40215 PyObject *resultobj;
40216 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40217 PyObject * obj0 = 0 ;
40218 char *kwnames[] = {
40219 (char *) "self", NULL
40220 };
40221
40222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
40223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40224 if (SWIG_arg_fail(1)) SWIG_fail;
40225 {
40226 PyThreadState* __tstate = wxPyBeginAllowThreads();
40227 (arg1)->Realize();
40228
40229 wxPyEndAllowThreads(__tstate);
40230 if (PyErr_Occurred()) SWIG_fail;
40231 }
40232 Py_INCREF(Py_None); resultobj = Py_None;
40233 return resultobj;
40234 fail:
40235 return NULL;
40236 }
40237
40238
40239 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40240 PyObject *resultobj;
40241 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40242 wxButton *arg2 = (wxButton *) 0 ;
40243 PyObject * obj0 = 0 ;
40244 PyObject * obj1 = 0 ;
40245 char *kwnames[] = {
40246 (char *) "self",(char *) "button", NULL
40247 };
40248
40249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
40250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40251 if (SWIG_arg_fail(1)) SWIG_fail;
40252 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40253 if (SWIG_arg_fail(2)) SWIG_fail;
40254 {
40255 PyThreadState* __tstate = wxPyBeginAllowThreads();
40256 (arg1)->SetAffirmativeButton(arg2);
40257
40258 wxPyEndAllowThreads(__tstate);
40259 if (PyErr_Occurred()) SWIG_fail;
40260 }
40261 Py_INCREF(Py_None); resultobj = Py_None;
40262 return resultobj;
40263 fail:
40264 return NULL;
40265 }
40266
40267
40268 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40269 PyObject *resultobj;
40270 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40271 wxButton *arg2 = (wxButton *) 0 ;
40272 PyObject * obj0 = 0 ;
40273 PyObject * obj1 = 0 ;
40274 char *kwnames[] = {
40275 (char *) "self",(char *) "button", NULL
40276 };
40277
40278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
40279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40280 if (SWIG_arg_fail(1)) SWIG_fail;
40281 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40282 if (SWIG_arg_fail(2)) SWIG_fail;
40283 {
40284 PyThreadState* __tstate = wxPyBeginAllowThreads();
40285 (arg1)->SetNegativeButton(arg2);
40286
40287 wxPyEndAllowThreads(__tstate);
40288 if (PyErr_Occurred()) SWIG_fail;
40289 }
40290 Py_INCREF(Py_None); resultobj = Py_None;
40291 return resultobj;
40292 fail:
40293 return NULL;
40294 }
40295
40296
40297 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
40298 PyObject *resultobj;
40299 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40300 wxButton *arg2 = (wxButton *) 0 ;
40301 PyObject * obj0 = 0 ;
40302 PyObject * obj1 = 0 ;
40303 char *kwnames[] = {
40304 (char *) "self",(char *) "button", NULL
40305 };
40306
40307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
40308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40309 if (SWIG_arg_fail(1)) SWIG_fail;
40310 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40311 if (SWIG_arg_fail(2)) SWIG_fail;
40312 {
40313 PyThreadState* __tstate = wxPyBeginAllowThreads();
40314 (arg1)->SetCancelButton(arg2);
40315
40316 wxPyEndAllowThreads(__tstate);
40317 if (PyErr_Occurred()) SWIG_fail;
40318 }
40319 Py_INCREF(Py_None); resultobj = Py_None;
40320 return resultobj;
40321 fail:
40322 return NULL;
40323 }
40324
40325
40326 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40327 PyObject *resultobj;
40328 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40329 wxButton *result;
40330 PyObject * obj0 = 0 ;
40331 char *kwnames[] = {
40332 (char *) "self", NULL
40333 };
40334
40335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
40336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40337 if (SWIG_arg_fail(1)) SWIG_fail;
40338 {
40339 PyThreadState* __tstate = wxPyBeginAllowThreads();
40340 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
40341
40342 wxPyEndAllowThreads(__tstate);
40343 if (PyErr_Occurred()) SWIG_fail;
40344 }
40345 {
40346 resultobj = wxPyMake_wxObject(result, 0);
40347 }
40348 return resultobj;
40349 fail:
40350 return NULL;
40351 }
40352
40353
40354 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
40355 PyObject *resultobj;
40356 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40357 wxButton *result;
40358 PyObject * obj0 = 0 ;
40359 char *kwnames[] = {
40360 (char *) "self", NULL
40361 };
40362
40363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
40364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40365 if (SWIG_arg_fail(1)) SWIG_fail;
40366 {
40367 PyThreadState* __tstate = wxPyBeginAllowThreads();
40368 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
40369
40370 wxPyEndAllowThreads(__tstate);
40371 if (PyErr_Occurred()) SWIG_fail;
40372 }
40373 {
40374 resultobj = wxPyMake_wxObject(result, 0);
40375 }
40376 return resultobj;
40377 fail:
40378 return NULL;
40379 }
40380
40381
40382 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40383 PyObject *resultobj;
40384 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40385 wxButton *result;
40386 PyObject * obj0 = 0 ;
40387 char *kwnames[] = {
40388 (char *) "self", NULL
40389 };
40390
40391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
40392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40393 if (SWIG_arg_fail(1)) SWIG_fail;
40394 {
40395 PyThreadState* __tstate = wxPyBeginAllowThreads();
40396 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
40397
40398 wxPyEndAllowThreads(__tstate);
40399 if (PyErr_Occurred()) SWIG_fail;
40400 }
40401 {
40402 resultobj = wxPyMake_wxObject(result, 0);
40403 }
40404 return resultobj;
40405 fail:
40406 return NULL;
40407 }
40408
40409
40410 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
40411 PyObject *resultobj;
40412 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40413 wxButton *result;
40414 PyObject * obj0 = 0 ;
40415 char *kwnames[] = {
40416 (char *) "self", NULL
40417 };
40418
40419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
40420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40421 if (SWIG_arg_fail(1)) SWIG_fail;
40422 {
40423 PyThreadState* __tstate = wxPyBeginAllowThreads();
40424 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
40425
40426 wxPyEndAllowThreads(__tstate);
40427 if (PyErr_Occurred()) SWIG_fail;
40428 }
40429 {
40430 resultobj = wxPyMake_wxObject(result, 0);
40431 }
40432 return resultobj;
40433 fail:
40434 return NULL;
40435 }
40436
40437
40438 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
40439 PyObject *resultobj;
40440 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40441 wxButton *result;
40442 PyObject * obj0 = 0 ;
40443 char *kwnames[] = {
40444 (char *) "self", NULL
40445 };
40446
40447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
40448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40449 if (SWIG_arg_fail(1)) SWIG_fail;
40450 {
40451 PyThreadState* __tstate = wxPyBeginAllowThreads();
40452 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
40453
40454 wxPyEndAllowThreads(__tstate);
40455 if (PyErr_Occurred()) SWIG_fail;
40456 }
40457 {
40458 resultobj = wxPyMake_wxObject(result, 0);
40459 }
40460 return resultobj;
40461 fail:
40462 return NULL;
40463 }
40464
40465
40466 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
40467 PyObject *obj;
40468 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40469 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
40470 Py_INCREF(obj);
40471 return Py_BuildValue((char *)"");
40472 }
40473 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40474 PyObject *resultobj;
40475 int arg1 = (int) 0 ;
40476 int arg2 = (int) 0 ;
40477 wxGBPosition *result;
40478 PyObject * obj0 = 0 ;
40479 PyObject * obj1 = 0 ;
40480 char *kwnames[] = {
40481 (char *) "row",(char *) "col", NULL
40482 };
40483
40484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
40485 if (obj0) {
40486 {
40487 arg1 = (int)(SWIG_As_int(obj0));
40488 if (SWIG_arg_fail(1)) SWIG_fail;
40489 }
40490 }
40491 if (obj1) {
40492 {
40493 arg2 = (int)(SWIG_As_int(obj1));
40494 if (SWIG_arg_fail(2)) SWIG_fail;
40495 }
40496 }
40497 {
40498 PyThreadState* __tstate = wxPyBeginAllowThreads();
40499 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
40500
40501 wxPyEndAllowThreads(__tstate);
40502 if (PyErr_Occurred()) SWIG_fail;
40503 }
40504 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
40505 return resultobj;
40506 fail:
40507 return NULL;
40508 }
40509
40510
40511 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
40512 PyObject *resultobj;
40513 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40514 int result;
40515 PyObject * obj0 = 0 ;
40516 char *kwnames[] = {
40517 (char *) "self", NULL
40518 };
40519
40520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
40521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40522 if (SWIG_arg_fail(1)) SWIG_fail;
40523 {
40524 PyThreadState* __tstate = wxPyBeginAllowThreads();
40525 result = (int)((wxGBPosition const *)arg1)->GetRow();
40526
40527 wxPyEndAllowThreads(__tstate);
40528 if (PyErr_Occurred()) SWIG_fail;
40529 }
40530 {
40531 resultobj = SWIG_From_int((int)(result));
40532 }
40533 return resultobj;
40534 fail:
40535 return NULL;
40536 }
40537
40538
40539 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
40540 PyObject *resultobj;
40541 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40542 int result;
40543 PyObject * obj0 = 0 ;
40544 char *kwnames[] = {
40545 (char *) "self", NULL
40546 };
40547
40548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
40549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40550 if (SWIG_arg_fail(1)) SWIG_fail;
40551 {
40552 PyThreadState* __tstate = wxPyBeginAllowThreads();
40553 result = (int)((wxGBPosition const *)arg1)->GetCol();
40554
40555 wxPyEndAllowThreads(__tstate);
40556 if (PyErr_Occurred()) SWIG_fail;
40557 }
40558 {
40559 resultobj = SWIG_From_int((int)(result));
40560 }
40561 return resultobj;
40562 fail:
40563 return NULL;
40564 }
40565
40566
40567 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
40568 PyObject *resultobj;
40569 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40570 int arg2 ;
40571 PyObject * obj0 = 0 ;
40572 PyObject * obj1 = 0 ;
40573 char *kwnames[] = {
40574 (char *) "self",(char *) "row", NULL
40575 };
40576
40577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
40578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40579 if (SWIG_arg_fail(1)) SWIG_fail;
40580 {
40581 arg2 = (int)(SWIG_As_int(obj1));
40582 if (SWIG_arg_fail(2)) SWIG_fail;
40583 }
40584 {
40585 PyThreadState* __tstate = wxPyBeginAllowThreads();
40586 (arg1)->SetRow(arg2);
40587
40588 wxPyEndAllowThreads(__tstate);
40589 if (PyErr_Occurred()) SWIG_fail;
40590 }
40591 Py_INCREF(Py_None); resultobj = Py_None;
40592 return resultobj;
40593 fail:
40594 return NULL;
40595 }
40596
40597
40598 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
40599 PyObject *resultobj;
40600 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40601 int arg2 ;
40602 PyObject * obj0 = 0 ;
40603 PyObject * obj1 = 0 ;
40604 char *kwnames[] = {
40605 (char *) "self",(char *) "col", NULL
40606 };
40607
40608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
40609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40610 if (SWIG_arg_fail(1)) SWIG_fail;
40611 {
40612 arg2 = (int)(SWIG_As_int(obj1));
40613 if (SWIG_arg_fail(2)) SWIG_fail;
40614 }
40615 {
40616 PyThreadState* __tstate = wxPyBeginAllowThreads();
40617 (arg1)->SetCol(arg2);
40618
40619 wxPyEndAllowThreads(__tstate);
40620 if (PyErr_Occurred()) SWIG_fail;
40621 }
40622 Py_INCREF(Py_None); resultobj = Py_None;
40623 return resultobj;
40624 fail:
40625 return NULL;
40626 }
40627
40628
40629 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
40630 PyObject *resultobj;
40631 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40632 wxGBPosition *arg2 = 0 ;
40633 bool result;
40634 wxGBPosition temp2 ;
40635 PyObject * obj0 = 0 ;
40636 PyObject * obj1 = 0 ;
40637 char *kwnames[] = {
40638 (char *) "self",(char *) "other", NULL
40639 };
40640
40641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
40642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40643 if (SWIG_arg_fail(1)) SWIG_fail;
40644 {
40645 arg2 = &temp2;
40646 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40647 }
40648 {
40649 PyThreadState* __tstate = wxPyBeginAllowThreads();
40650 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
40651
40652 wxPyEndAllowThreads(__tstate);
40653 if (PyErr_Occurred()) SWIG_fail;
40654 }
40655 {
40656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40657 }
40658 return resultobj;
40659 fail:
40660 return NULL;
40661 }
40662
40663
40664 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
40665 PyObject *resultobj;
40666 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40667 wxGBPosition *arg2 = 0 ;
40668 bool result;
40669 wxGBPosition temp2 ;
40670 PyObject * obj0 = 0 ;
40671 PyObject * obj1 = 0 ;
40672 char *kwnames[] = {
40673 (char *) "self",(char *) "other", NULL
40674 };
40675
40676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
40677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40678 if (SWIG_arg_fail(1)) SWIG_fail;
40679 {
40680 arg2 = &temp2;
40681 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40682 }
40683 {
40684 PyThreadState* __tstate = wxPyBeginAllowThreads();
40685 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
40686
40687 wxPyEndAllowThreads(__tstate);
40688 if (PyErr_Occurred()) SWIG_fail;
40689 }
40690 {
40691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40692 }
40693 return resultobj;
40694 fail:
40695 return NULL;
40696 }
40697
40698
40699 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
40700 PyObject *resultobj;
40701 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40702 int arg2 = (int) 0 ;
40703 int arg3 = (int) 0 ;
40704 PyObject * obj0 = 0 ;
40705 PyObject * obj1 = 0 ;
40706 PyObject * obj2 = 0 ;
40707 char *kwnames[] = {
40708 (char *) "self",(char *) "row",(char *) "col", NULL
40709 };
40710
40711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
40712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40713 if (SWIG_arg_fail(1)) SWIG_fail;
40714 if (obj1) {
40715 {
40716 arg2 = (int)(SWIG_As_int(obj1));
40717 if (SWIG_arg_fail(2)) SWIG_fail;
40718 }
40719 }
40720 if (obj2) {
40721 {
40722 arg3 = (int)(SWIG_As_int(obj2));
40723 if (SWIG_arg_fail(3)) SWIG_fail;
40724 }
40725 }
40726 {
40727 PyThreadState* __tstate = wxPyBeginAllowThreads();
40728 wxGBPosition_Set(arg1,arg2,arg3);
40729
40730 wxPyEndAllowThreads(__tstate);
40731 if (PyErr_Occurred()) SWIG_fail;
40732 }
40733 Py_INCREF(Py_None); resultobj = Py_None;
40734 return resultobj;
40735 fail:
40736 return NULL;
40737 }
40738
40739
40740 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
40741 PyObject *resultobj;
40742 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40743 PyObject *result;
40744 PyObject * obj0 = 0 ;
40745 char *kwnames[] = {
40746 (char *) "self", NULL
40747 };
40748
40749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
40750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40751 if (SWIG_arg_fail(1)) SWIG_fail;
40752 {
40753 PyThreadState* __tstate = wxPyBeginAllowThreads();
40754 result = (PyObject *)wxGBPosition_Get(arg1);
40755
40756 wxPyEndAllowThreads(__tstate);
40757 if (PyErr_Occurred()) SWIG_fail;
40758 }
40759 resultobj = result;
40760 return resultobj;
40761 fail:
40762 return NULL;
40763 }
40764
40765
40766 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
40767 PyObject *obj;
40768 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40769 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
40770 Py_INCREF(obj);
40771 return Py_BuildValue((char *)"");
40772 }
40773 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
40774 PyObject *resultobj;
40775 int arg1 = (int) 1 ;
40776 int arg2 = (int) 1 ;
40777 wxGBSpan *result;
40778 PyObject * obj0 = 0 ;
40779 PyObject * obj1 = 0 ;
40780 char *kwnames[] = {
40781 (char *) "rowspan",(char *) "colspan", NULL
40782 };
40783
40784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
40785 if (obj0) {
40786 {
40787 arg1 = (int)(SWIG_As_int(obj0));
40788 if (SWIG_arg_fail(1)) SWIG_fail;
40789 }
40790 }
40791 if (obj1) {
40792 {
40793 arg2 = (int)(SWIG_As_int(obj1));
40794 if (SWIG_arg_fail(2)) SWIG_fail;
40795 }
40796 }
40797 {
40798 PyThreadState* __tstate = wxPyBeginAllowThreads();
40799 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
40800
40801 wxPyEndAllowThreads(__tstate);
40802 if (PyErr_Occurred()) SWIG_fail;
40803 }
40804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
40805 return resultobj;
40806 fail:
40807 return NULL;
40808 }
40809
40810
40811 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
40812 PyObject *resultobj;
40813 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40814 int result;
40815 PyObject * obj0 = 0 ;
40816 char *kwnames[] = {
40817 (char *) "self", NULL
40818 };
40819
40820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
40821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40822 if (SWIG_arg_fail(1)) SWIG_fail;
40823 {
40824 PyThreadState* __tstate = wxPyBeginAllowThreads();
40825 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
40826
40827 wxPyEndAllowThreads(__tstate);
40828 if (PyErr_Occurred()) SWIG_fail;
40829 }
40830 {
40831 resultobj = SWIG_From_int((int)(result));
40832 }
40833 return resultobj;
40834 fail:
40835 return NULL;
40836 }
40837
40838
40839 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
40840 PyObject *resultobj;
40841 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40842 int result;
40843 PyObject * obj0 = 0 ;
40844 char *kwnames[] = {
40845 (char *) "self", NULL
40846 };
40847
40848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
40849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40850 if (SWIG_arg_fail(1)) SWIG_fail;
40851 {
40852 PyThreadState* __tstate = wxPyBeginAllowThreads();
40853 result = (int)((wxGBSpan const *)arg1)->GetColspan();
40854
40855 wxPyEndAllowThreads(__tstate);
40856 if (PyErr_Occurred()) SWIG_fail;
40857 }
40858 {
40859 resultobj = SWIG_From_int((int)(result));
40860 }
40861 return resultobj;
40862 fail:
40863 return NULL;
40864 }
40865
40866
40867 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
40868 PyObject *resultobj;
40869 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40870 int arg2 ;
40871 PyObject * obj0 = 0 ;
40872 PyObject * obj1 = 0 ;
40873 char *kwnames[] = {
40874 (char *) "self",(char *) "rowspan", NULL
40875 };
40876
40877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
40878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40879 if (SWIG_arg_fail(1)) SWIG_fail;
40880 {
40881 arg2 = (int)(SWIG_As_int(obj1));
40882 if (SWIG_arg_fail(2)) SWIG_fail;
40883 }
40884 {
40885 PyThreadState* __tstate = wxPyBeginAllowThreads();
40886 (arg1)->SetRowspan(arg2);
40887
40888 wxPyEndAllowThreads(__tstate);
40889 if (PyErr_Occurred()) SWIG_fail;
40890 }
40891 Py_INCREF(Py_None); resultobj = Py_None;
40892 return resultobj;
40893 fail:
40894 return NULL;
40895 }
40896
40897
40898 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
40899 PyObject *resultobj;
40900 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40901 int arg2 ;
40902 PyObject * obj0 = 0 ;
40903 PyObject * obj1 = 0 ;
40904 char *kwnames[] = {
40905 (char *) "self",(char *) "colspan", NULL
40906 };
40907
40908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
40909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40910 if (SWIG_arg_fail(1)) SWIG_fail;
40911 {
40912 arg2 = (int)(SWIG_As_int(obj1));
40913 if (SWIG_arg_fail(2)) SWIG_fail;
40914 }
40915 {
40916 PyThreadState* __tstate = wxPyBeginAllowThreads();
40917 (arg1)->SetColspan(arg2);
40918
40919 wxPyEndAllowThreads(__tstate);
40920 if (PyErr_Occurred()) SWIG_fail;
40921 }
40922 Py_INCREF(Py_None); resultobj = Py_None;
40923 return resultobj;
40924 fail:
40925 return NULL;
40926 }
40927
40928
40929 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
40930 PyObject *resultobj;
40931 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40932 wxGBSpan *arg2 = 0 ;
40933 bool result;
40934 wxGBSpan temp2 ;
40935 PyObject * obj0 = 0 ;
40936 PyObject * obj1 = 0 ;
40937 char *kwnames[] = {
40938 (char *) "self",(char *) "other", NULL
40939 };
40940
40941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
40942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40943 if (SWIG_arg_fail(1)) SWIG_fail;
40944 {
40945 arg2 = &temp2;
40946 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
40947 }
40948 {
40949 PyThreadState* __tstate = wxPyBeginAllowThreads();
40950 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
40951
40952 wxPyEndAllowThreads(__tstate);
40953 if (PyErr_Occurred()) SWIG_fail;
40954 }
40955 {
40956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40957 }
40958 return resultobj;
40959 fail:
40960 return NULL;
40961 }
40962
40963
40964 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
40965 PyObject *resultobj;
40966 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40967 wxGBSpan *arg2 = 0 ;
40968 bool result;
40969 wxGBSpan temp2 ;
40970 PyObject * obj0 = 0 ;
40971 PyObject * obj1 = 0 ;
40972 char *kwnames[] = {
40973 (char *) "self",(char *) "other", NULL
40974 };
40975
40976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
40977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40978 if (SWIG_arg_fail(1)) SWIG_fail;
40979 {
40980 arg2 = &temp2;
40981 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
40982 }
40983 {
40984 PyThreadState* __tstate = wxPyBeginAllowThreads();
40985 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
40986
40987 wxPyEndAllowThreads(__tstate);
40988 if (PyErr_Occurred()) SWIG_fail;
40989 }
40990 {
40991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40992 }
40993 return resultobj;
40994 fail:
40995 return NULL;
40996 }
40997
40998
40999 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41000 PyObject *resultobj;
41001 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41002 int arg2 = (int) 1 ;
41003 int arg3 = (int) 1 ;
41004 PyObject * obj0 = 0 ;
41005 PyObject * obj1 = 0 ;
41006 PyObject * obj2 = 0 ;
41007 char *kwnames[] = {
41008 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
41009 };
41010
41011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41013 if (SWIG_arg_fail(1)) SWIG_fail;
41014 if (obj1) {
41015 {
41016 arg2 = (int)(SWIG_As_int(obj1));
41017 if (SWIG_arg_fail(2)) SWIG_fail;
41018 }
41019 }
41020 if (obj2) {
41021 {
41022 arg3 = (int)(SWIG_As_int(obj2));
41023 if (SWIG_arg_fail(3)) SWIG_fail;
41024 }
41025 }
41026 {
41027 PyThreadState* __tstate = wxPyBeginAllowThreads();
41028 wxGBSpan_Set(arg1,arg2,arg3);
41029
41030 wxPyEndAllowThreads(__tstate);
41031 if (PyErr_Occurred()) SWIG_fail;
41032 }
41033 Py_INCREF(Py_None); resultobj = Py_None;
41034 return resultobj;
41035 fail:
41036 return NULL;
41037 }
41038
41039
41040 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41041 PyObject *resultobj;
41042 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41043 PyObject *result;
41044 PyObject * obj0 = 0 ;
41045 char *kwnames[] = {
41046 (char *) "self", NULL
41047 };
41048
41049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
41050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41051 if (SWIG_arg_fail(1)) SWIG_fail;
41052 {
41053 PyThreadState* __tstate = wxPyBeginAllowThreads();
41054 result = (PyObject *)wxGBSpan_Get(arg1);
41055
41056 wxPyEndAllowThreads(__tstate);
41057 if (PyErr_Occurred()) SWIG_fail;
41058 }
41059 resultobj = result;
41060 return resultobj;
41061 fail:
41062 return NULL;
41063 }
41064
41065
41066 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
41067 PyObject *obj;
41068 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41069 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
41070 Py_INCREF(obj);
41071 return Py_BuildValue((char *)"");
41072 }
41073 static int _wrap_DefaultSpan_set(PyObject *) {
41074 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
41075 return 1;
41076 }
41077
41078
41079 static PyObject *_wrap_DefaultSpan_get(void) {
41080 PyObject *pyobj;
41081
41082 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
41083 return pyobj;
41084 }
41085
41086
41087 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
41088 PyObject *resultobj;
41089 wxGBSizerItem *result;
41090 char *kwnames[] = {
41091 NULL
41092 };
41093
41094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
41095 {
41096 PyThreadState* __tstate = wxPyBeginAllowThreads();
41097 result = (wxGBSizerItem *)new wxGBSizerItem();
41098
41099 wxPyEndAllowThreads(__tstate);
41100 if (PyErr_Occurred()) SWIG_fail;
41101 }
41102 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41103 return resultobj;
41104 fail:
41105 return NULL;
41106 }
41107
41108
41109 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
41110 PyObject *resultobj;
41111 wxWindow *arg1 = (wxWindow *) 0 ;
41112 wxGBPosition *arg2 = 0 ;
41113 wxGBSpan *arg3 = 0 ;
41114 int arg4 ;
41115 int arg5 ;
41116 PyObject *arg6 = (PyObject *) NULL ;
41117 wxGBSizerItem *result;
41118 wxGBPosition temp2 ;
41119 wxGBSpan temp3 ;
41120 PyObject * obj0 = 0 ;
41121 PyObject * obj1 = 0 ;
41122 PyObject * obj2 = 0 ;
41123 PyObject * obj3 = 0 ;
41124 PyObject * obj4 = 0 ;
41125 PyObject * obj5 = 0 ;
41126 char *kwnames[] = {
41127 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41128 };
41129
41130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41132 if (SWIG_arg_fail(1)) SWIG_fail;
41133 {
41134 arg2 = &temp2;
41135 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41136 }
41137 {
41138 arg3 = &temp3;
41139 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41140 }
41141 {
41142 arg4 = (int)(SWIG_As_int(obj3));
41143 if (SWIG_arg_fail(4)) SWIG_fail;
41144 }
41145 {
41146 arg5 = (int)(SWIG_As_int(obj4));
41147 if (SWIG_arg_fail(5)) SWIG_fail;
41148 }
41149 if (obj5) {
41150 arg6 = obj5;
41151 }
41152 {
41153 PyThreadState* __tstate = wxPyBeginAllowThreads();
41154 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41155
41156 wxPyEndAllowThreads(__tstate);
41157 if (PyErr_Occurred()) SWIG_fail;
41158 }
41159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41160 return resultobj;
41161 fail:
41162 return NULL;
41163 }
41164
41165
41166 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41167 PyObject *resultobj;
41168 wxSizer *arg1 = (wxSizer *) 0 ;
41169 wxGBPosition *arg2 = 0 ;
41170 wxGBSpan *arg3 = 0 ;
41171 int arg4 ;
41172 int arg5 ;
41173 PyObject *arg6 = (PyObject *) NULL ;
41174 wxGBSizerItem *result;
41175 wxGBPosition temp2 ;
41176 wxGBSpan temp3 ;
41177 PyObject * obj0 = 0 ;
41178 PyObject * obj1 = 0 ;
41179 PyObject * obj2 = 0 ;
41180 PyObject * obj3 = 0 ;
41181 PyObject * obj4 = 0 ;
41182 PyObject * obj5 = 0 ;
41183 char *kwnames[] = {
41184 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41185 };
41186
41187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41189 if (SWIG_arg_fail(1)) SWIG_fail;
41190 {
41191 arg2 = &temp2;
41192 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41193 }
41194 {
41195 arg3 = &temp3;
41196 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41197 }
41198 {
41199 arg4 = (int)(SWIG_As_int(obj3));
41200 if (SWIG_arg_fail(4)) SWIG_fail;
41201 }
41202 {
41203 arg5 = (int)(SWIG_As_int(obj4));
41204 if (SWIG_arg_fail(5)) SWIG_fail;
41205 }
41206 if (obj5) {
41207 arg6 = obj5;
41208 }
41209 {
41210 PyThreadState* __tstate = wxPyBeginAllowThreads();
41211 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41212
41213 wxPyEndAllowThreads(__tstate);
41214 if (PyErr_Occurred()) SWIG_fail;
41215 }
41216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41217 return resultobj;
41218 fail:
41219 return NULL;
41220 }
41221
41222
41223 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
41224 PyObject *resultobj;
41225 int arg1 ;
41226 int arg2 ;
41227 wxGBPosition *arg3 = 0 ;
41228 wxGBSpan *arg4 = 0 ;
41229 int arg5 ;
41230 int arg6 ;
41231 PyObject *arg7 = (PyObject *) NULL ;
41232 wxGBSizerItem *result;
41233 wxGBPosition temp3 ;
41234 wxGBSpan temp4 ;
41235 PyObject * obj0 = 0 ;
41236 PyObject * obj1 = 0 ;
41237 PyObject * obj2 = 0 ;
41238 PyObject * obj3 = 0 ;
41239 PyObject * obj4 = 0 ;
41240 PyObject * obj5 = 0 ;
41241 PyObject * obj6 = 0 ;
41242 char *kwnames[] = {
41243 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41244 };
41245
41246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41247 {
41248 arg1 = (int)(SWIG_As_int(obj0));
41249 if (SWIG_arg_fail(1)) SWIG_fail;
41250 }
41251 {
41252 arg2 = (int)(SWIG_As_int(obj1));
41253 if (SWIG_arg_fail(2)) SWIG_fail;
41254 }
41255 {
41256 arg3 = &temp3;
41257 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41258 }
41259 {
41260 arg4 = &temp4;
41261 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
41262 }
41263 {
41264 arg5 = (int)(SWIG_As_int(obj4));
41265 if (SWIG_arg_fail(5)) SWIG_fail;
41266 }
41267 {
41268 arg6 = (int)(SWIG_As_int(obj5));
41269 if (SWIG_arg_fail(6)) SWIG_fail;
41270 }
41271 if (obj6) {
41272 arg7 = obj6;
41273 }
41274 {
41275 PyThreadState* __tstate = wxPyBeginAllowThreads();
41276 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
41277
41278 wxPyEndAllowThreads(__tstate);
41279 if (PyErr_Occurred()) SWIG_fail;
41280 }
41281 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41282 return resultobj;
41283 fail:
41284 return NULL;
41285 }
41286
41287
41288 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
41289 PyObject *resultobj;
41290 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41291 wxGBPosition result;
41292 PyObject * obj0 = 0 ;
41293 char *kwnames[] = {
41294 (char *) "self", NULL
41295 };
41296
41297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
41298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41299 if (SWIG_arg_fail(1)) SWIG_fail;
41300 {
41301 PyThreadState* __tstate = wxPyBeginAllowThreads();
41302 result = ((wxGBSizerItem const *)arg1)->GetPos();
41303
41304 wxPyEndAllowThreads(__tstate);
41305 if (PyErr_Occurred()) SWIG_fail;
41306 }
41307 {
41308 wxGBPosition * resultptr;
41309 resultptr = new wxGBPosition((wxGBPosition &)(result));
41310 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41311 }
41312 return resultobj;
41313 fail:
41314 return NULL;
41315 }
41316
41317
41318 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41319 PyObject *resultobj;
41320 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41321 wxGBSpan result;
41322 PyObject * obj0 = 0 ;
41323 char *kwnames[] = {
41324 (char *) "self", NULL
41325 };
41326
41327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
41328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41329 if (SWIG_arg_fail(1)) SWIG_fail;
41330 {
41331 PyThreadState* __tstate = wxPyBeginAllowThreads();
41332 result = ((wxGBSizerItem const *)arg1)->GetSpan();
41333
41334 wxPyEndAllowThreads(__tstate);
41335 if (PyErr_Occurred()) SWIG_fail;
41336 }
41337 {
41338 wxGBSpan * resultptr;
41339 resultptr = new wxGBSpan((wxGBSpan &)(result));
41340 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
41341 }
41342 return resultobj;
41343 fail:
41344 return NULL;
41345 }
41346
41347
41348 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
41349 PyObject *resultobj;
41350 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41351 wxGBPosition *arg2 = 0 ;
41352 bool result;
41353 wxGBPosition temp2 ;
41354 PyObject * obj0 = 0 ;
41355 PyObject * obj1 = 0 ;
41356 char *kwnames[] = {
41357 (char *) "self",(char *) "pos", NULL
41358 };
41359
41360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
41361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41362 if (SWIG_arg_fail(1)) SWIG_fail;
41363 {
41364 arg2 = &temp2;
41365 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41366 }
41367 {
41368 PyThreadState* __tstate = wxPyBeginAllowThreads();
41369 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
41370
41371 wxPyEndAllowThreads(__tstate);
41372 if (PyErr_Occurred()) SWIG_fail;
41373 }
41374 {
41375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41376 }
41377 return resultobj;
41378 fail:
41379 return NULL;
41380 }
41381
41382
41383 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41384 PyObject *resultobj;
41385 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41386 wxGBSpan *arg2 = 0 ;
41387 bool result;
41388 wxGBSpan temp2 ;
41389 PyObject * obj0 = 0 ;
41390 PyObject * obj1 = 0 ;
41391 char *kwnames[] = {
41392 (char *) "self",(char *) "span", NULL
41393 };
41394
41395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
41396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41397 if (SWIG_arg_fail(1)) SWIG_fail;
41398 {
41399 arg2 = &temp2;
41400 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41401 }
41402 {
41403 PyThreadState* __tstate = wxPyBeginAllowThreads();
41404 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
41405
41406 wxPyEndAllowThreads(__tstate);
41407 if (PyErr_Occurred()) SWIG_fail;
41408 }
41409 {
41410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41411 }
41412 return resultobj;
41413 fail:
41414 return NULL;
41415 }
41416
41417
41418 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
41419 PyObject *resultobj;
41420 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41421 wxGBSizerItem *arg2 = 0 ;
41422 bool result;
41423 PyObject * obj0 = 0 ;
41424 PyObject * obj1 = 0 ;
41425 char *kwnames[] = {
41426 (char *) "self",(char *) "other", NULL
41427 };
41428
41429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
41430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41431 if (SWIG_arg_fail(1)) SWIG_fail;
41432 {
41433 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41434 if (SWIG_arg_fail(2)) SWIG_fail;
41435 if (arg2 == NULL) {
41436 SWIG_null_ref("wxGBSizerItem");
41437 }
41438 if (SWIG_arg_fail(2)) SWIG_fail;
41439 }
41440 {
41441 PyThreadState* __tstate = wxPyBeginAllowThreads();
41442 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
41443
41444 wxPyEndAllowThreads(__tstate);
41445 if (PyErr_Occurred()) SWIG_fail;
41446 }
41447 {
41448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41449 }
41450 return resultobj;
41451 fail:
41452 return NULL;
41453 }
41454
41455
41456 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
41457 PyObject *resultobj;
41458 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41459 wxGBPosition *arg2 = 0 ;
41460 wxGBSpan *arg3 = 0 ;
41461 bool result;
41462 wxGBPosition temp2 ;
41463 wxGBSpan temp3 ;
41464 PyObject * obj0 = 0 ;
41465 PyObject * obj1 = 0 ;
41466 PyObject * obj2 = 0 ;
41467 char *kwnames[] = {
41468 (char *) "self",(char *) "pos",(char *) "span", NULL
41469 };
41470
41471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
41472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41473 if (SWIG_arg_fail(1)) SWIG_fail;
41474 {
41475 arg2 = &temp2;
41476 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41477 }
41478 {
41479 arg3 = &temp3;
41480 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41481 }
41482 {
41483 PyThreadState* __tstate = wxPyBeginAllowThreads();
41484 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
41485
41486 wxPyEndAllowThreads(__tstate);
41487 if (PyErr_Occurred()) SWIG_fail;
41488 }
41489 {
41490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41491 }
41492 return resultobj;
41493 fail:
41494 return NULL;
41495 }
41496
41497
41498 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
41499 PyObject *resultobj;
41500 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41501 wxGBPosition result;
41502 PyObject * obj0 = 0 ;
41503 char *kwnames[] = {
41504 (char *) "self", NULL
41505 };
41506
41507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
41508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41509 if (SWIG_arg_fail(1)) SWIG_fail;
41510 {
41511 PyThreadState* __tstate = wxPyBeginAllowThreads();
41512 result = wxGBSizerItem_GetEndPos(arg1);
41513
41514 wxPyEndAllowThreads(__tstate);
41515 if (PyErr_Occurred()) SWIG_fail;
41516 }
41517 {
41518 wxGBPosition * resultptr;
41519 resultptr = new wxGBPosition((wxGBPosition &)(result));
41520 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41521 }
41522 return resultobj;
41523 fail:
41524 return NULL;
41525 }
41526
41527
41528 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41529 PyObject *resultobj;
41530 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41531 wxGridBagSizer *result;
41532 PyObject * obj0 = 0 ;
41533 char *kwnames[] = {
41534 (char *) "self", NULL
41535 };
41536
41537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
41538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41539 if (SWIG_arg_fail(1)) SWIG_fail;
41540 {
41541 PyThreadState* __tstate = wxPyBeginAllowThreads();
41542 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
41543
41544 wxPyEndAllowThreads(__tstate);
41545 if (PyErr_Occurred()) SWIG_fail;
41546 }
41547 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
41548 return resultobj;
41549 fail:
41550 return NULL;
41551 }
41552
41553
41554 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41555 PyObject *resultobj;
41556 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41557 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
41558 PyObject * obj0 = 0 ;
41559 PyObject * obj1 = 0 ;
41560 char *kwnames[] = {
41561 (char *) "self",(char *) "sizer", NULL
41562 };
41563
41564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
41565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41566 if (SWIG_arg_fail(1)) SWIG_fail;
41567 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41568 if (SWIG_arg_fail(2)) SWIG_fail;
41569 {
41570 PyThreadState* __tstate = wxPyBeginAllowThreads();
41571 (arg1)->SetGBSizer(arg2);
41572
41573 wxPyEndAllowThreads(__tstate);
41574 if (PyErr_Occurred()) SWIG_fail;
41575 }
41576 Py_INCREF(Py_None); resultobj = Py_None;
41577 return resultobj;
41578 fail:
41579 return NULL;
41580 }
41581
41582
41583 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
41584 PyObject *obj;
41585 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41586 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
41587 Py_INCREF(obj);
41588 return Py_BuildValue((char *)"");
41589 }
41590 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41591 PyObject *resultobj;
41592 int arg1 = (int) 0 ;
41593 int arg2 = (int) 0 ;
41594 wxGridBagSizer *result;
41595 PyObject * obj0 = 0 ;
41596 PyObject * obj1 = 0 ;
41597 char *kwnames[] = {
41598 (char *) "vgap",(char *) "hgap", NULL
41599 };
41600
41601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
41602 if (obj0) {
41603 {
41604 arg1 = (int)(SWIG_As_int(obj0));
41605 if (SWIG_arg_fail(1)) SWIG_fail;
41606 }
41607 }
41608 if (obj1) {
41609 {
41610 arg2 = (int)(SWIG_As_int(obj1));
41611 if (SWIG_arg_fail(2)) SWIG_fail;
41612 }
41613 }
41614 {
41615 PyThreadState* __tstate = wxPyBeginAllowThreads();
41616 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
41617
41618 wxPyEndAllowThreads(__tstate);
41619 if (PyErr_Occurred()) SWIG_fail;
41620 }
41621 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
41622 return resultobj;
41623 fail:
41624 return NULL;
41625 }
41626
41627
41628 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
41629 PyObject *resultobj;
41630 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41631 PyObject *arg2 = (PyObject *) 0 ;
41632 wxGBPosition *arg3 = 0 ;
41633 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
41634 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
41635 int arg5 = (int) 0 ;
41636 int arg6 = (int) 0 ;
41637 PyObject *arg7 = (PyObject *) NULL ;
41638 wxGBSizerItem *result;
41639 wxGBPosition temp3 ;
41640 wxGBSpan temp4 ;
41641 PyObject * obj0 = 0 ;
41642 PyObject * obj1 = 0 ;
41643 PyObject * obj2 = 0 ;
41644 PyObject * obj3 = 0 ;
41645 PyObject * obj4 = 0 ;
41646 PyObject * obj5 = 0 ;
41647 PyObject * obj6 = 0 ;
41648 char *kwnames[] = {
41649 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41650 };
41651
41652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41654 if (SWIG_arg_fail(1)) SWIG_fail;
41655 arg2 = obj1;
41656 {
41657 arg3 = &temp3;
41658 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41659 }
41660 if (obj3) {
41661 {
41662 arg4 = &temp4;
41663 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
41664 }
41665 }
41666 if (obj4) {
41667 {
41668 arg5 = (int)(SWIG_As_int(obj4));
41669 if (SWIG_arg_fail(5)) SWIG_fail;
41670 }
41671 }
41672 if (obj5) {
41673 {
41674 arg6 = (int)(SWIG_As_int(obj5));
41675 if (SWIG_arg_fail(6)) SWIG_fail;
41676 }
41677 }
41678 if (obj6) {
41679 arg7 = obj6;
41680 }
41681 {
41682 PyThreadState* __tstate = wxPyBeginAllowThreads();
41683 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
41684
41685 wxPyEndAllowThreads(__tstate);
41686 if (PyErr_Occurred()) SWIG_fail;
41687 }
41688 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
41689 return resultobj;
41690 fail:
41691 return NULL;
41692 }
41693
41694
41695 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
41696 PyObject *resultobj;
41697 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41698 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
41699 wxGBSizerItem *result;
41700 PyObject * obj0 = 0 ;
41701 PyObject * obj1 = 0 ;
41702 char *kwnames[] = {
41703 (char *) "self",(char *) "item", NULL
41704 };
41705
41706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
41707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41708 if (SWIG_arg_fail(1)) SWIG_fail;
41709 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41710 if (SWIG_arg_fail(2)) SWIG_fail;
41711 {
41712 PyThreadState* __tstate = wxPyBeginAllowThreads();
41713 result = (wxGBSizerItem *)(arg1)->Add(arg2);
41714
41715 wxPyEndAllowThreads(__tstate);
41716 if (PyErr_Occurred()) SWIG_fail;
41717 }
41718 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
41719 return resultobj;
41720 fail:
41721 return NULL;
41722 }
41723
41724
41725 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41726 PyObject *resultobj;
41727 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41728 int arg2 ;
41729 int arg3 ;
41730 wxSize result;
41731 PyObject * obj0 = 0 ;
41732 PyObject * obj1 = 0 ;
41733 PyObject * obj2 = 0 ;
41734 char *kwnames[] = {
41735 (char *) "self",(char *) "row",(char *) "col", NULL
41736 };
41737
41738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
41739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41740 if (SWIG_arg_fail(1)) SWIG_fail;
41741 {
41742 arg2 = (int)(SWIG_As_int(obj1));
41743 if (SWIG_arg_fail(2)) SWIG_fail;
41744 }
41745 {
41746 arg3 = (int)(SWIG_As_int(obj2));
41747 if (SWIG_arg_fail(3)) SWIG_fail;
41748 }
41749 {
41750 PyThreadState* __tstate = wxPyBeginAllowThreads();
41751 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
41752
41753 wxPyEndAllowThreads(__tstate);
41754 if (PyErr_Occurred()) SWIG_fail;
41755 }
41756 {
41757 wxSize * resultptr;
41758 resultptr = new wxSize((wxSize &)(result));
41759 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41760 }
41761 return resultobj;
41762 fail:
41763 return NULL;
41764 }
41765
41766
41767 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41768 PyObject *resultobj;
41769 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41770 wxSize result;
41771 PyObject * obj0 = 0 ;
41772 char *kwnames[] = {
41773 (char *) "self", NULL
41774 };
41775
41776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
41777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41778 if (SWIG_arg_fail(1)) SWIG_fail;
41779 {
41780 PyThreadState* __tstate = wxPyBeginAllowThreads();
41781 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
41782
41783 wxPyEndAllowThreads(__tstate);
41784 if (PyErr_Occurred()) SWIG_fail;
41785 }
41786 {
41787 wxSize * resultptr;
41788 resultptr = new wxSize((wxSize &)(result));
41789 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41790 }
41791 return resultobj;
41792 fail:
41793 return NULL;
41794 }
41795
41796
41797 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41798 PyObject *resultobj;
41799 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41800 wxSize *arg2 = 0 ;
41801 wxSize temp2 ;
41802 PyObject * obj0 = 0 ;
41803 PyObject * obj1 = 0 ;
41804 char *kwnames[] = {
41805 (char *) "self",(char *) "sz", NULL
41806 };
41807
41808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
41809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41810 if (SWIG_arg_fail(1)) SWIG_fail;
41811 {
41812 arg2 = &temp2;
41813 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
41814 }
41815 {
41816 PyThreadState* __tstate = wxPyBeginAllowThreads();
41817 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
41818
41819 wxPyEndAllowThreads(__tstate);
41820 if (PyErr_Occurred()) SWIG_fail;
41821 }
41822 Py_INCREF(Py_None); resultobj = Py_None;
41823 return resultobj;
41824 fail:
41825 return NULL;
41826 }
41827
41828
41829 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
41830 PyObject *resultobj;
41831 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41832 wxWindow *arg2 = (wxWindow *) 0 ;
41833 wxGBPosition result;
41834 PyObject * obj0 = 0 ;
41835 PyObject * obj1 = 0 ;
41836
41837 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
41838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41839 if (SWIG_arg_fail(1)) SWIG_fail;
41840 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41841 if (SWIG_arg_fail(2)) SWIG_fail;
41842 {
41843 PyThreadState* __tstate = wxPyBeginAllowThreads();
41844 result = (arg1)->GetItemPosition(arg2);
41845
41846 wxPyEndAllowThreads(__tstate);
41847 if (PyErr_Occurred()) SWIG_fail;
41848 }
41849 {
41850 wxGBPosition * resultptr;
41851 resultptr = new wxGBPosition((wxGBPosition &)(result));
41852 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41853 }
41854 return resultobj;
41855 fail:
41856 return NULL;
41857 }
41858
41859
41860 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
41861 PyObject *resultobj;
41862 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41863 wxSizer *arg2 = (wxSizer *) 0 ;
41864 wxGBPosition result;
41865 PyObject * obj0 = 0 ;
41866 PyObject * obj1 = 0 ;
41867
41868 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
41869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41870 if (SWIG_arg_fail(1)) SWIG_fail;
41871 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41872 if (SWIG_arg_fail(2)) SWIG_fail;
41873 {
41874 PyThreadState* __tstate = wxPyBeginAllowThreads();
41875 result = (arg1)->GetItemPosition(arg2);
41876
41877 wxPyEndAllowThreads(__tstate);
41878 if (PyErr_Occurred()) SWIG_fail;
41879 }
41880 {
41881 wxGBPosition * resultptr;
41882 resultptr = new wxGBPosition((wxGBPosition &)(result));
41883 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41884 }
41885 return resultobj;
41886 fail:
41887 return NULL;
41888 }
41889
41890
41891 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
41892 PyObject *resultobj;
41893 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41894 size_t arg2 ;
41895 wxGBPosition result;
41896 PyObject * obj0 = 0 ;
41897 PyObject * obj1 = 0 ;
41898
41899 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
41900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41901 if (SWIG_arg_fail(1)) SWIG_fail;
41902 {
41903 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41904 if (SWIG_arg_fail(2)) SWIG_fail;
41905 }
41906 {
41907 PyThreadState* __tstate = wxPyBeginAllowThreads();
41908 result = (arg1)->GetItemPosition(arg2);
41909
41910 wxPyEndAllowThreads(__tstate);
41911 if (PyErr_Occurred()) SWIG_fail;
41912 }
41913 {
41914 wxGBPosition * resultptr;
41915 resultptr = new wxGBPosition((wxGBPosition &)(result));
41916 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41917 }
41918 return resultobj;
41919 fail:
41920 return NULL;
41921 }
41922
41923
41924 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
41925 int argc;
41926 PyObject *argv[3];
41927 int ii;
41928
41929 argc = PyObject_Length(args);
41930 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
41931 argv[ii] = PyTuple_GetItem(args,ii);
41932 }
41933 if (argc == 2) {
41934 int _v;
41935 {
41936 void *ptr;
41937 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41938 _v = 0;
41939 PyErr_Clear();
41940 } else {
41941 _v = 1;
41942 }
41943 }
41944 if (_v) {
41945 {
41946 void *ptr;
41947 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
41948 _v = 0;
41949 PyErr_Clear();
41950 } else {
41951 _v = 1;
41952 }
41953 }
41954 if (_v) {
41955 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
41956 }
41957 }
41958 }
41959 if (argc == 2) {
41960 int _v;
41961 {
41962 void *ptr;
41963 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41964 _v = 0;
41965 PyErr_Clear();
41966 } else {
41967 _v = 1;
41968 }
41969 }
41970 if (_v) {
41971 {
41972 void *ptr;
41973 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
41974 _v = 0;
41975 PyErr_Clear();
41976 } else {
41977 _v = 1;
41978 }
41979 }
41980 if (_v) {
41981 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
41982 }
41983 }
41984 }
41985 if (argc == 2) {
41986 int _v;
41987 {
41988 void *ptr;
41989 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41990 _v = 0;
41991 PyErr_Clear();
41992 } else {
41993 _v = 1;
41994 }
41995 }
41996 if (_v) {
41997 _v = SWIG_Check_unsigned_SS_long(argv[1]);
41998 if (_v) {
41999 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
42000 }
42001 }
42002 }
42003
42004 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
42005 return NULL;
42006 }
42007
42008
42009 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42010 PyObject *resultobj;
42011 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42012 wxWindow *arg2 = (wxWindow *) 0 ;
42013 wxGBPosition *arg3 = 0 ;
42014 bool result;
42015 wxGBPosition temp3 ;
42016 PyObject * obj0 = 0 ;
42017 PyObject * obj1 = 0 ;
42018 PyObject * obj2 = 0 ;
42019
42020 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42022 if (SWIG_arg_fail(1)) SWIG_fail;
42023 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42024 if (SWIG_arg_fail(2)) SWIG_fail;
42025 {
42026 arg3 = &temp3;
42027 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42028 }
42029 {
42030 PyThreadState* __tstate = wxPyBeginAllowThreads();
42031 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42032
42033 wxPyEndAllowThreads(__tstate);
42034 if (PyErr_Occurred()) SWIG_fail;
42035 }
42036 {
42037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42038 }
42039 return resultobj;
42040 fail:
42041 return NULL;
42042 }
42043
42044
42045 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42046 PyObject *resultobj;
42047 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42048 wxSizer *arg2 = (wxSizer *) 0 ;
42049 wxGBPosition *arg3 = 0 ;
42050 bool result;
42051 wxGBPosition temp3 ;
42052 PyObject * obj0 = 0 ;
42053 PyObject * obj1 = 0 ;
42054 PyObject * obj2 = 0 ;
42055
42056 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42058 if (SWIG_arg_fail(1)) SWIG_fail;
42059 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42060 if (SWIG_arg_fail(2)) SWIG_fail;
42061 {
42062 arg3 = &temp3;
42063 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42064 }
42065 {
42066 PyThreadState* __tstate = wxPyBeginAllowThreads();
42067 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42068
42069 wxPyEndAllowThreads(__tstate);
42070 if (PyErr_Occurred()) SWIG_fail;
42071 }
42072 {
42073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42074 }
42075 return resultobj;
42076 fail:
42077 return NULL;
42078 }
42079
42080
42081 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42082 PyObject *resultobj;
42083 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42084 size_t arg2 ;
42085 wxGBPosition *arg3 = 0 ;
42086 bool result;
42087 wxGBPosition temp3 ;
42088 PyObject * obj0 = 0 ;
42089 PyObject * obj1 = 0 ;
42090 PyObject * obj2 = 0 ;
42091
42092 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42094 if (SWIG_arg_fail(1)) SWIG_fail;
42095 {
42096 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42097 if (SWIG_arg_fail(2)) SWIG_fail;
42098 }
42099 {
42100 arg3 = &temp3;
42101 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42102 }
42103 {
42104 PyThreadState* __tstate = wxPyBeginAllowThreads();
42105 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42106
42107 wxPyEndAllowThreads(__tstate);
42108 if (PyErr_Occurred()) SWIG_fail;
42109 }
42110 {
42111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42112 }
42113 return resultobj;
42114 fail:
42115 return NULL;
42116 }
42117
42118
42119 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
42120 int argc;
42121 PyObject *argv[4];
42122 int ii;
42123
42124 argc = PyObject_Length(args);
42125 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42126 argv[ii] = PyTuple_GetItem(args,ii);
42127 }
42128 if (argc == 3) {
42129 int _v;
42130 {
42131 void *ptr;
42132 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42133 _v = 0;
42134 PyErr_Clear();
42135 } else {
42136 _v = 1;
42137 }
42138 }
42139 if (_v) {
42140 {
42141 void *ptr;
42142 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42143 _v = 0;
42144 PyErr_Clear();
42145 } else {
42146 _v = 1;
42147 }
42148 }
42149 if (_v) {
42150 {
42151 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42152 }
42153 if (_v) {
42154 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
42155 }
42156 }
42157 }
42158 }
42159 if (argc == 3) {
42160 int _v;
42161 {
42162 void *ptr;
42163 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42164 _v = 0;
42165 PyErr_Clear();
42166 } else {
42167 _v = 1;
42168 }
42169 }
42170 if (_v) {
42171 {
42172 void *ptr;
42173 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42174 _v = 0;
42175 PyErr_Clear();
42176 } else {
42177 _v = 1;
42178 }
42179 }
42180 if (_v) {
42181 {
42182 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42183 }
42184 if (_v) {
42185 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
42186 }
42187 }
42188 }
42189 }
42190 if (argc == 3) {
42191 int _v;
42192 {
42193 void *ptr;
42194 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42195 _v = 0;
42196 PyErr_Clear();
42197 } else {
42198 _v = 1;
42199 }
42200 }
42201 if (_v) {
42202 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42203 if (_v) {
42204 {
42205 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42206 }
42207 if (_v) {
42208 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
42209 }
42210 }
42211 }
42212 }
42213
42214 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
42215 return NULL;
42216 }
42217
42218
42219 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42220 PyObject *resultobj;
42221 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42222 wxWindow *arg2 = (wxWindow *) 0 ;
42223 wxGBSpan result;
42224 PyObject * obj0 = 0 ;
42225 PyObject * obj1 = 0 ;
42226
42227 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42229 if (SWIG_arg_fail(1)) SWIG_fail;
42230 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42231 if (SWIG_arg_fail(2)) SWIG_fail;
42232 {
42233 PyThreadState* __tstate = wxPyBeginAllowThreads();
42234 result = (arg1)->GetItemSpan(arg2);
42235
42236 wxPyEndAllowThreads(__tstate);
42237 if (PyErr_Occurred()) SWIG_fail;
42238 }
42239 {
42240 wxGBSpan * resultptr;
42241 resultptr = new wxGBSpan((wxGBSpan &)(result));
42242 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42243 }
42244 return resultobj;
42245 fail:
42246 return NULL;
42247 }
42248
42249
42250 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42251 PyObject *resultobj;
42252 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42253 wxSizer *arg2 = (wxSizer *) 0 ;
42254 wxGBSpan result;
42255 PyObject * obj0 = 0 ;
42256 PyObject * obj1 = 0 ;
42257
42258 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42260 if (SWIG_arg_fail(1)) SWIG_fail;
42261 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42262 if (SWIG_arg_fail(2)) SWIG_fail;
42263 {
42264 PyThreadState* __tstate = wxPyBeginAllowThreads();
42265 result = (arg1)->GetItemSpan(arg2);
42266
42267 wxPyEndAllowThreads(__tstate);
42268 if (PyErr_Occurred()) SWIG_fail;
42269 }
42270 {
42271 wxGBSpan * resultptr;
42272 resultptr = new wxGBSpan((wxGBSpan &)(result));
42273 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42274 }
42275 return resultobj;
42276 fail:
42277 return NULL;
42278 }
42279
42280
42281 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42282 PyObject *resultobj;
42283 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42284 size_t arg2 ;
42285 wxGBSpan result;
42286 PyObject * obj0 = 0 ;
42287 PyObject * obj1 = 0 ;
42288
42289 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42291 if (SWIG_arg_fail(1)) SWIG_fail;
42292 {
42293 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42294 if (SWIG_arg_fail(2)) SWIG_fail;
42295 }
42296 {
42297 PyThreadState* __tstate = wxPyBeginAllowThreads();
42298 result = (arg1)->GetItemSpan(arg2);
42299
42300 wxPyEndAllowThreads(__tstate);
42301 if (PyErr_Occurred()) SWIG_fail;
42302 }
42303 {
42304 wxGBSpan * resultptr;
42305 resultptr = new wxGBSpan((wxGBSpan &)(result));
42306 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42307 }
42308 return resultobj;
42309 fail:
42310 return NULL;
42311 }
42312
42313
42314 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
42315 int argc;
42316 PyObject *argv[3];
42317 int ii;
42318
42319 argc = PyObject_Length(args);
42320 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42321 argv[ii] = PyTuple_GetItem(args,ii);
42322 }
42323 if (argc == 2) {
42324 int _v;
42325 {
42326 void *ptr;
42327 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42328 _v = 0;
42329 PyErr_Clear();
42330 } else {
42331 _v = 1;
42332 }
42333 }
42334 if (_v) {
42335 {
42336 void *ptr;
42337 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42338 _v = 0;
42339 PyErr_Clear();
42340 } else {
42341 _v = 1;
42342 }
42343 }
42344 if (_v) {
42345 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
42346 }
42347 }
42348 }
42349 if (argc == 2) {
42350 int _v;
42351 {
42352 void *ptr;
42353 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42354 _v = 0;
42355 PyErr_Clear();
42356 } else {
42357 _v = 1;
42358 }
42359 }
42360 if (_v) {
42361 {
42362 void *ptr;
42363 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42364 _v = 0;
42365 PyErr_Clear();
42366 } else {
42367 _v = 1;
42368 }
42369 }
42370 if (_v) {
42371 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
42372 }
42373 }
42374 }
42375 if (argc == 2) {
42376 int _v;
42377 {
42378 void *ptr;
42379 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42380 _v = 0;
42381 PyErr_Clear();
42382 } else {
42383 _v = 1;
42384 }
42385 }
42386 if (_v) {
42387 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42388 if (_v) {
42389 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
42390 }
42391 }
42392 }
42393
42394 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
42395 return NULL;
42396 }
42397
42398
42399 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42400 PyObject *resultobj;
42401 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42402 wxWindow *arg2 = (wxWindow *) 0 ;
42403 wxGBSpan *arg3 = 0 ;
42404 bool result;
42405 wxGBSpan temp3 ;
42406 PyObject * obj0 = 0 ;
42407 PyObject * obj1 = 0 ;
42408 PyObject * obj2 = 0 ;
42409
42410 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42412 if (SWIG_arg_fail(1)) SWIG_fail;
42413 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42414 if (SWIG_arg_fail(2)) SWIG_fail;
42415 {
42416 arg3 = &temp3;
42417 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42418 }
42419 {
42420 PyThreadState* __tstate = wxPyBeginAllowThreads();
42421 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42422
42423 wxPyEndAllowThreads(__tstate);
42424 if (PyErr_Occurred()) SWIG_fail;
42425 }
42426 {
42427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42428 }
42429 return resultobj;
42430 fail:
42431 return NULL;
42432 }
42433
42434
42435 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42436 PyObject *resultobj;
42437 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42438 wxSizer *arg2 = (wxSizer *) 0 ;
42439 wxGBSpan *arg3 = 0 ;
42440 bool result;
42441 wxGBSpan temp3 ;
42442 PyObject * obj0 = 0 ;
42443 PyObject * obj1 = 0 ;
42444 PyObject * obj2 = 0 ;
42445
42446 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42448 if (SWIG_arg_fail(1)) SWIG_fail;
42449 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42450 if (SWIG_arg_fail(2)) SWIG_fail;
42451 {
42452 arg3 = &temp3;
42453 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42454 }
42455 {
42456 PyThreadState* __tstate = wxPyBeginAllowThreads();
42457 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42458
42459 wxPyEndAllowThreads(__tstate);
42460 if (PyErr_Occurred()) SWIG_fail;
42461 }
42462 {
42463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42464 }
42465 return resultobj;
42466 fail:
42467 return NULL;
42468 }
42469
42470
42471 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42472 PyObject *resultobj;
42473 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42474 size_t arg2 ;
42475 wxGBSpan *arg3 = 0 ;
42476 bool result;
42477 wxGBSpan temp3 ;
42478 PyObject * obj0 = 0 ;
42479 PyObject * obj1 = 0 ;
42480 PyObject * obj2 = 0 ;
42481
42482 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42484 if (SWIG_arg_fail(1)) SWIG_fail;
42485 {
42486 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42487 if (SWIG_arg_fail(2)) SWIG_fail;
42488 }
42489 {
42490 arg3 = &temp3;
42491 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42492 }
42493 {
42494 PyThreadState* __tstate = wxPyBeginAllowThreads();
42495 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42496
42497 wxPyEndAllowThreads(__tstate);
42498 if (PyErr_Occurred()) SWIG_fail;
42499 }
42500 {
42501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42502 }
42503 return resultobj;
42504 fail:
42505 return NULL;
42506 }
42507
42508
42509 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
42510 int argc;
42511 PyObject *argv[4];
42512 int ii;
42513
42514 argc = PyObject_Length(args);
42515 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42516 argv[ii] = PyTuple_GetItem(args,ii);
42517 }
42518 if (argc == 3) {
42519 int _v;
42520 {
42521 void *ptr;
42522 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42523 _v = 0;
42524 PyErr_Clear();
42525 } else {
42526 _v = 1;
42527 }
42528 }
42529 if (_v) {
42530 {
42531 void *ptr;
42532 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42533 _v = 0;
42534 PyErr_Clear();
42535 } else {
42536 _v = 1;
42537 }
42538 }
42539 if (_v) {
42540 {
42541 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42542 }
42543 if (_v) {
42544 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
42545 }
42546 }
42547 }
42548 }
42549 if (argc == 3) {
42550 int _v;
42551 {
42552 void *ptr;
42553 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42554 _v = 0;
42555 PyErr_Clear();
42556 } else {
42557 _v = 1;
42558 }
42559 }
42560 if (_v) {
42561 {
42562 void *ptr;
42563 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42564 _v = 0;
42565 PyErr_Clear();
42566 } else {
42567 _v = 1;
42568 }
42569 }
42570 if (_v) {
42571 {
42572 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42573 }
42574 if (_v) {
42575 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
42576 }
42577 }
42578 }
42579 }
42580 if (argc == 3) {
42581 int _v;
42582 {
42583 void *ptr;
42584 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42585 _v = 0;
42586 PyErr_Clear();
42587 } else {
42588 _v = 1;
42589 }
42590 }
42591 if (_v) {
42592 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42593 if (_v) {
42594 {
42595 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42596 }
42597 if (_v) {
42598 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
42599 }
42600 }
42601 }
42602 }
42603
42604 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
42605 return NULL;
42606 }
42607
42608
42609 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
42610 PyObject *resultobj;
42611 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42612 wxWindow *arg2 = (wxWindow *) 0 ;
42613 wxGBSizerItem *result;
42614 PyObject * obj0 = 0 ;
42615 PyObject * obj1 = 0 ;
42616
42617 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
42618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42619 if (SWIG_arg_fail(1)) SWIG_fail;
42620 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42621 if (SWIG_arg_fail(2)) SWIG_fail;
42622 {
42623 PyThreadState* __tstate = wxPyBeginAllowThreads();
42624 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
42625
42626 wxPyEndAllowThreads(__tstate);
42627 if (PyErr_Occurred()) SWIG_fail;
42628 }
42629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42630 return resultobj;
42631 fail:
42632 return NULL;
42633 }
42634
42635
42636 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
42637 PyObject *resultobj;
42638 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42639 wxSizer *arg2 = (wxSizer *) 0 ;
42640 wxGBSizerItem *result;
42641 PyObject * obj0 = 0 ;
42642 PyObject * obj1 = 0 ;
42643
42644 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
42645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42646 if (SWIG_arg_fail(1)) SWIG_fail;
42647 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42648 if (SWIG_arg_fail(2)) SWIG_fail;
42649 {
42650 PyThreadState* __tstate = wxPyBeginAllowThreads();
42651 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
42652
42653 wxPyEndAllowThreads(__tstate);
42654 if (PyErr_Occurred()) SWIG_fail;
42655 }
42656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42657 return resultobj;
42658 fail:
42659 return NULL;
42660 }
42661
42662
42663 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
42664 int argc;
42665 PyObject *argv[3];
42666 int ii;
42667
42668 argc = PyObject_Length(args);
42669 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42670 argv[ii] = PyTuple_GetItem(args,ii);
42671 }
42672 if (argc == 2) {
42673 int _v;
42674 {
42675 void *ptr;
42676 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42677 _v = 0;
42678 PyErr_Clear();
42679 } else {
42680 _v = 1;
42681 }
42682 }
42683 if (_v) {
42684 {
42685 void *ptr;
42686 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42687 _v = 0;
42688 PyErr_Clear();
42689 } else {
42690 _v = 1;
42691 }
42692 }
42693 if (_v) {
42694 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
42695 }
42696 }
42697 }
42698 if (argc == 2) {
42699 int _v;
42700 {
42701 void *ptr;
42702 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42703 _v = 0;
42704 PyErr_Clear();
42705 } else {
42706 _v = 1;
42707 }
42708 }
42709 if (_v) {
42710 {
42711 void *ptr;
42712 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42713 _v = 0;
42714 PyErr_Clear();
42715 } else {
42716 _v = 1;
42717 }
42718 }
42719 if (_v) {
42720 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
42721 }
42722 }
42723 }
42724
42725 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
42726 return NULL;
42727 }
42728
42729
42730 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42731 PyObject *resultobj;
42732 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42733 wxGBPosition *arg2 = 0 ;
42734 wxGBSizerItem *result;
42735 wxGBPosition temp2 ;
42736 PyObject * obj0 = 0 ;
42737 PyObject * obj1 = 0 ;
42738 char *kwnames[] = {
42739 (char *) "self",(char *) "pos", NULL
42740 };
42741
42742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
42743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42744 if (SWIG_arg_fail(1)) SWIG_fail;
42745 {
42746 arg2 = &temp2;
42747 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42748 }
42749 {
42750 PyThreadState* __tstate = wxPyBeginAllowThreads();
42751 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
42752
42753 wxPyEndAllowThreads(__tstate);
42754 if (PyErr_Occurred()) SWIG_fail;
42755 }
42756 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42757 return resultobj;
42758 fail:
42759 return NULL;
42760 }
42761
42762
42763 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
42764 PyObject *resultobj;
42765 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42766 wxPoint *arg2 = 0 ;
42767 wxGBSizerItem *result;
42768 wxPoint temp2 ;
42769 PyObject * obj0 = 0 ;
42770 PyObject * obj1 = 0 ;
42771 char *kwnames[] = {
42772 (char *) "self",(char *) "pt", NULL
42773 };
42774
42775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
42776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42777 if (SWIG_arg_fail(1)) SWIG_fail;
42778 {
42779 arg2 = &temp2;
42780 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
42781 }
42782 {
42783 PyThreadState* __tstate = wxPyBeginAllowThreads();
42784 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
42785
42786 wxPyEndAllowThreads(__tstate);
42787 if (PyErr_Occurred()) SWIG_fail;
42788 }
42789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42790 return resultobj;
42791 fail:
42792 return NULL;
42793 }
42794
42795
42796 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
42797 PyObject *resultobj;
42798 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42799 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42800 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
42801 bool result;
42802 PyObject * obj0 = 0 ;
42803 PyObject * obj1 = 0 ;
42804 PyObject * obj2 = 0 ;
42805 char *kwnames[] = {
42806 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
42807 };
42808
42809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
42810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42811 if (SWIG_arg_fail(1)) SWIG_fail;
42812 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42813 if (SWIG_arg_fail(2)) SWIG_fail;
42814 if (obj2) {
42815 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42816 if (SWIG_arg_fail(3)) SWIG_fail;
42817 }
42818 {
42819 PyThreadState* __tstate = wxPyBeginAllowThreads();
42820 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
42821
42822 wxPyEndAllowThreads(__tstate);
42823 if (PyErr_Occurred()) SWIG_fail;
42824 }
42825 {
42826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42827 }
42828 return resultobj;
42829 fail:
42830 return NULL;
42831 }
42832
42833
42834 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
42835 PyObject *resultobj;
42836 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42837 wxGBPosition *arg2 = 0 ;
42838 wxGBSpan *arg3 = 0 ;
42839 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
42840 bool result;
42841 wxGBPosition temp2 ;
42842 wxGBSpan temp3 ;
42843 PyObject * obj0 = 0 ;
42844 PyObject * obj1 = 0 ;
42845 PyObject * obj2 = 0 ;
42846 PyObject * obj3 = 0 ;
42847 char *kwnames[] = {
42848 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
42849 };
42850
42851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
42852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42853 if (SWIG_arg_fail(1)) SWIG_fail;
42854 {
42855 arg2 = &temp2;
42856 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42857 }
42858 {
42859 arg3 = &temp3;
42860 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42861 }
42862 if (obj3) {
42863 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42864 if (SWIG_arg_fail(4)) SWIG_fail;
42865 }
42866 {
42867 PyThreadState* __tstate = wxPyBeginAllowThreads();
42868 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
42869
42870 wxPyEndAllowThreads(__tstate);
42871 if (PyErr_Occurred()) SWIG_fail;
42872 }
42873 {
42874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42875 }
42876 return resultobj;
42877 fail:
42878 return NULL;
42879 }
42880
42881
42882 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
42883 PyObject *obj;
42884 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42885 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
42886 Py_INCREF(obj);
42887 return Py_BuildValue((char *)"");
42888 }
42889 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42890 PyObject *resultobj;
42891 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42892 wxRelationship arg2 ;
42893 wxWindow *arg3 = (wxWindow *) 0 ;
42894 wxEdge arg4 ;
42895 int arg5 = (int) 0 ;
42896 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
42897 PyObject * obj0 = 0 ;
42898 PyObject * obj1 = 0 ;
42899 PyObject * obj2 = 0 ;
42900 PyObject * obj3 = 0 ;
42901 PyObject * obj4 = 0 ;
42902 PyObject * obj5 = 0 ;
42903 char *kwnames[] = {
42904 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
42905 };
42906
42907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42909 if (SWIG_arg_fail(1)) SWIG_fail;
42910 {
42911 arg2 = (wxRelationship)(SWIG_As_int(obj1));
42912 if (SWIG_arg_fail(2)) SWIG_fail;
42913 }
42914 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42915 if (SWIG_arg_fail(3)) SWIG_fail;
42916 {
42917 arg4 = (wxEdge)(SWIG_As_int(obj3));
42918 if (SWIG_arg_fail(4)) SWIG_fail;
42919 }
42920 if (obj4) {
42921 {
42922 arg5 = (int)(SWIG_As_int(obj4));
42923 if (SWIG_arg_fail(5)) SWIG_fail;
42924 }
42925 }
42926 if (obj5) {
42927 {
42928 arg6 = (int)(SWIG_As_int(obj5));
42929 if (SWIG_arg_fail(6)) SWIG_fail;
42930 }
42931 }
42932 {
42933 PyThreadState* __tstate = wxPyBeginAllowThreads();
42934 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
42935
42936 wxPyEndAllowThreads(__tstate);
42937 if (PyErr_Occurred()) SWIG_fail;
42938 }
42939 Py_INCREF(Py_None); resultobj = Py_None;
42940 return resultobj;
42941 fail:
42942 return NULL;
42943 }
42944
42945
42946 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
42947 PyObject *resultobj;
42948 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42949 wxWindow *arg2 = (wxWindow *) 0 ;
42950 int arg3 = (int) 0 ;
42951 PyObject * obj0 = 0 ;
42952 PyObject * obj1 = 0 ;
42953 PyObject * obj2 = 0 ;
42954 char *kwnames[] = {
42955 (char *) "self",(char *) "sibling",(char *) "marg", NULL
42956 };
42957
42958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
42959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42960 if (SWIG_arg_fail(1)) SWIG_fail;
42961 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42962 if (SWIG_arg_fail(2)) SWIG_fail;
42963 if (obj2) {
42964 {
42965 arg3 = (int)(SWIG_As_int(obj2));
42966 if (SWIG_arg_fail(3)) SWIG_fail;
42967 }
42968 }
42969 {
42970 PyThreadState* __tstate = wxPyBeginAllowThreads();
42971 (arg1)->LeftOf(arg2,arg3);
42972
42973 wxPyEndAllowThreads(__tstate);
42974 if (PyErr_Occurred()) SWIG_fail;
42975 }
42976 Py_INCREF(Py_None); resultobj = Py_None;
42977 return resultobj;
42978 fail:
42979 return NULL;
42980 }
42981
42982
42983 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
42984 PyObject *resultobj;
42985 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42986 wxWindow *arg2 = (wxWindow *) 0 ;
42987 int arg3 = (int) 0 ;
42988 PyObject * obj0 = 0 ;
42989 PyObject * obj1 = 0 ;
42990 PyObject * obj2 = 0 ;
42991 char *kwnames[] = {
42992 (char *) "self",(char *) "sibling",(char *) "marg", NULL
42993 };
42994
42995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
42996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42997 if (SWIG_arg_fail(1)) SWIG_fail;
42998 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42999 if (SWIG_arg_fail(2)) SWIG_fail;
43000 if (obj2) {
43001 {
43002 arg3 = (int)(SWIG_As_int(obj2));
43003 if (SWIG_arg_fail(3)) SWIG_fail;
43004 }
43005 }
43006 {
43007 PyThreadState* __tstate = wxPyBeginAllowThreads();
43008 (arg1)->RightOf(arg2,arg3);
43009
43010 wxPyEndAllowThreads(__tstate);
43011 if (PyErr_Occurred()) SWIG_fail;
43012 }
43013 Py_INCREF(Py_None); resultobj = Py_None;
43014 return resultobj;
43015 fail:
43016 return NULL;
43017 }
43018
43019
43020 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
43021 PyObject *resultobj;
43022 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43023 wxWindow *arg2 = (wxWindow *) 0 ;
43024 int arg3 = (int) 0 ;
43025 PyObject * obj0 = 0 ;
43026 PyObject * obj1 = 0 ;
43027 PyObject * obj2 = 0 ;
43028 char *kwnames[] = {
43029 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43030 };
43031
43032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
43033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43034 if (SWIG_arg_fail(1)) SWIG_fail;
43035 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43036 if (SWIG_arg_fail(2)) SWIG_fail;
43037 if (obj2) {
43038 {
43039 arg3 = (int)(SWIG_As_int(obj2));
43040 if (SWIG_arg_fail(3)) SWIG_fail;
43041 }
43042 }
43043 {
43044 PyThreadState* __tstate = wxPyBeginAllowThreads();
43045 (arg1)->Above(arg2,arg3);
43046
43047 wxPyEndAllowThreads(__tstate);
43048 if (PyErr_Occurred()) SWIG_fail;
43049 }
43050 Py_INCREF(Py_None); resultobj = Py_None;
43051 return resultobj;
43052 fail:
43053 return NULL;
43054 }
43055
43056
43057 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
43058 PyObject *resultobj;
43059 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43060 wxWindow *arg2 = (wxWindow *) 0 ;
43061 int arg3 = (int) 0 ;
43062 PyObject * obj0 = 0 ;
43063 PyObject * obj1 = 0 ;
43064 PyObject * obj2 = 0 ;
43065 char *kwnames[] = {
43066 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43067 };
43068
43069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
43070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43071 if (SWIG_arg_fail(1)) SWIG_fail;
43072 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43073 if (SWIG_arg_fail(2)) SWIG_fail;
43074 if (obj2) {
43075 {
43076 arg3 = (int)(SWIG_As_int(obj2));
43077 if (SWIG_arg_fail(3)) SWIG_fail;
43078 }
43079 }
43080 {
43081 PyThreadState* __tstate = wxPyBeginAllowThreads();
43082 (arg1)->Below(arg2,arg3);
43083
43084 wxPyEndAllowThreads(__tstate);
43085 if (PyErr_Occurred()) SWIG_fail;
43086 }
43087 Py_INCREF(Py_None); resultobj = Py_None;
43088 return resultobj;
43089 fail:
43090 return NULL;
43091 }
43092
43093
43094 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
43095 PyObject *resultobj;
43096 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43097 wxWindow *arg2 = (wxWindow *) 0 ;
43098 wxEdge arg3 ;
43099 int arg4 = (int) 0 ;
43100 PyObject * obj0 = 0 ;
43101 PyObject * obj1 = 0 ;
43102 PyObject * obj2 = 0 ;
43103 PyObject * obj3 = 0 ;
43104 char *kwnames[] = {
43105 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
43106 };
43107
43108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43110 if (SWIG_arg_fail(1)) SWIG_fail;
43111 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43112 if (SWIG_arg_fail(2)) SWIG_fail;
43113 {
43114 arg3 = (wxEdge)(SWIG_As_int(obj2));
43115 if (SWIG_arg_fail(3)) SWIG_fail;
43116 }
43117 if (obj3) {
43118 {
43119 arg4 = (int)(SWIG_As_int(obj3));
43120 if (SWIG_arg_fail(4)) SWIG_fail;
43121 }
43122 }
43123 {
43124 PyThreadState* __tstate = wxPyBeginAllowThreads();
43125 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
43126
43127 wxPyEndAllowThreads(__tstate);
43128 if (PyErr_Occurred()) SWIG_fail;
43129 }
43130 Py_INCREF(Py_None); resultobj = Py_None;
43131 return resultobj;
43132 fail:
43133 return NULL;
43134 }
43135
43136
43137 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
43138 PyObject *resultobj;
43139 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43140 wxWindow *arg2 = (wxWindow *) 0 ;
43141 wxEdge arg3 ;
43142 int arg4 ;
43143 PyObject * obj0 = 0 ;
43144 PyObject * obj1 = 0 ;
43145 PyObject * obj2 = 0 ;
43146 PyObject * obj3 = 0 ;
43147 char *kwnames[] = {
43148 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
43149 };
43150
43151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43153 if (SWIG_arg_fail(1)) SWIG_fail;
43154 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43155 if (SWIG_arg_fail(2)) SWIG_fail;
43156 {
43157 arg3 = (wxEdge)(SWIG_As_int(obj2));
43158 if (SWIG_arg_fail(3)) SWIG_fail;
43159 }
43160 {
43161 arg4 = (int)(SWIG_As_int(obj3));
43162 if (SWIG_arg_fail(4)) SWIG_fail;
43163 }
43164 {
43165 PyThreadState* __tstate = wxPyBeginAllowThreads();
43166 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
43167
43168 wxPyEndAllowThreads(__tstate);
43169 if (PyErr_Occurred()) SWIG_fail;
43170 }
43171 Py_INCREF(Py_None); resultobj = Py_None;
43172 return resultobj;
43173 fail:
43174 return NULL;
43175 }
43176
43177
43178 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
43179 PyObject *resultobj;
43180 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43181 int arg2 ;
43182 PyObject * obj0 = 0 ;
43183 PyObject * obj1 = 0 ;
43184 char *kwnames[] = {
43185 (char *) "self",(char *) "val", NULL
43186 };
43187
43188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
43189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43190 if (SWIG_arg_fail(1)) SWIG_fail;
43191 {
43192 arg2 = (int)(SWIG_As_int(obj1));
43193 if (SWIG_arg_fail(2)) SWIG_fail;
43194 }
43195 {
43196 PyThreadState* __tstate = wxPyBeginAllowThreads();
43197 (arg1)->Absolute(arg2);
43198
43199 wxPyEndAllowThreads(__tstate);
43200 if (PyErr_Occurred()) SWIG_fail;
43201 }
43202 Py_INCREF(Py_None); resultobj = Py_None;
43203 return resultobj;
43204 fail:
43205 return NULL;
43206 }
43207
43208
43209 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
43210 PyObject *resultobj;
43211 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43212 PyObject * obj0 = 0 ;
43213 char *kwnames[] = {
43214 (char *) "self", NULL
43215 };
43216
43217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
43218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43219 if (SWIG_arg_fail(1)) SWIG_fail;
43220 {
43221 PyThreadState* __tstate = wxPyBeginAllowThreads();
43222 (arg1)->Unconstrained();
43223
43224 wxPyEndAllowThreads(__tstate);
43225 if (PyErr_Occurred()) SWIG_fail;
43226 }
43227 Py_INCREF(Py_None); resultobj = Py_None;
43228 return resultobj;
43229 fail:
43230 return NULL;
43231 }
43232
43233
43234 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
43235 PyObject *resultobj;
43236 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43237 PyObject * obj0 = 0 ;
43238 char *kwnames[] = {
43239 (char *) "self", NULL
43240 };
43241
43242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
43243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43244 if (SWIG_arg_fail(1)) SWIG_fail;
43245 {
43246 PyThreadState* __tstate = wxPyBeginAllowThreads();
43247 (arg1)->AsIs();
43248
43249 wxPyEndAllowThreads(__tstate);
43250 if (PyErr_Occurred()) SWIG_fail;
43251 }
43252 Py_INCREF(Py_None); resultobj = Py_None;
43253 return resultobj;
43254 fail:
43255 return NULL;
43256 }
43257
43258
43259 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43260 PyObject *resultobj;
43261 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43262 wxWindow *result;
43263 PyObject * obj0 = 0 ;
43264 char *kwnames[] = {
43265 (char *) "self", NULL
43266 };
43267
43268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
43269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43270 if (SWIG_arg_fail(1)) SWIG_fail;
43271 {
43272 PyThreadState* __tstate = wxPyBeginAllowThreads();
43273 result = (wxWindow *)(arg1)->GetOtherWindow();
43274
43275 wxPyEndAllowThreads(__tstate);
43276 if (PyErr_Occurred()) SWIG_fail;
43277 }
43278 {
43279 resultobj = wxPyMake_wxObject(result, 0);
43280 }
43281 return resultobj;
43282 fail:
43283 return NULL;
43284 }
43285
43286
43287 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43288 PyObject *resultobj;
43289 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43290 wxEdge result;
43291 PyObject * obj0 = 0 ;
43292 char *kwnames[] = {
43293 (char *) "self", NULL
43294 };
43295
43296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
43297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43298 if (SWIG_arg_fail(1)) SWIG_fail;
43299 {
43300 PyThreadState* __tstate = wxPyBeginAllowThreads();
43301 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
43302
43303 wxPyEndAllowThreads(__tstate);
43304 if (PyErr_Occurred()) SWIG_fail;
43305 }
43306 resultobj = SWIG_From_int((result));
43307 return resultobj;
43308 fail:
43309 return NULL;
43310 }
43311
43312
43313 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43314 PyObject *resultobj;
43315 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43316 wxEdge arg2 ;
43317 PyObject * obj0 = 0 ;
43318 PyObject * obj1 = 0 ;
43319 char *kwnames[] = {
43320 (char *) "self",(char *) "which", NULL
43321 };
43322
43323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
43324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43325 if (SWIG_arg_fail(1)) SWIG_fail;
43326 {
43327 arg2 = (wxEdge)(SWIG_As_int(obj1));
43328 if (SWIG_arg_fail(2)) SWIG_fail;
43329 }
43330 {
43331 PyThreadState* __tstate = wxPyBeginAllowThreads();
43332 (arg1)->SetEdge((wxEdge )arg2);
43333
43334 wxPyEndAllowThreads(__tstate);
43335 if (PyErr_Occurred()) SWIG_fail;
43336 }
43337 Py_INCREF(Py_None); resultobj = Py_None;
43338 return resultobj;
43339 fail:
43340 return NULL;
43341 }
43342
43343
43344 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
43345 PyObject *resultobj;
43346 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43347 int arg2 ;
43348 PyObject * obj0 = 0 ;
43349 PyObject * obj1 = 0 ;
43350 char *kwnames[] = {
43351 (char *) "self",(char *) "v", NULL
43352 };
43353
43354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
43355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43356 if (SWIG_arg_fail(1)) SWIG_fail;
43357 {
43358 arg2 = (int)(SWIG_As_int(obj1));
43359 if (SWIG_arg_fail(2)) SWIG_fail;
43360 }
43361 {
43362 PyThreadState* __tstate = wxPyBeginAllowThreads();
43363 (arg1)->SetValue(arg2);
43364
43365 wxPyEndAllowThreads(__tstate);
43366 if (PyErr_Occurred()) SWIG_fail;
43367 }
43368 Py_INCREF(Py_None); resultobj = Py_None;
43369 return resultobj;
43370 fail:
43371 return NULL;
43372 }
43373
43374
43375 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
43376 PyObject *resultobj;
43377 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43378 int result;
43379 PyObject * obj0 = 0 ;
43380 char *kwnames[] = {
43381 (char *) "self", NULL
43382 };
43383
43384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
43385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43386 if (SWIG_arg_fail(1)) SWIG_fail;
43387 {
43388 PyThreadState* __tstate = wxPyBeginAllowThreads();
43389 result = (int)(arg1)->GetMargin();
43390
43391 wxPyEndAllowThreads(__tstate);
43392 if (PyErr_Occurred()) SWIG_fail;
43393 }
43394 {
43395 resultobj = SWIG_From_int((int)(result));
43396 }
43397 return resultobj;
43398 fail:
43399 return NULL;
43400 }
43401
43402
43403 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
43404 PyObject *resultobj;
43405 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43406 int arg2 ;
43407 PyObject * obj0 = 0 ;
43408 PyObject * obj1 = 0 ;
43409 char *kwnames[] = {
43410 (char *) "self",(char *) "m", NULL
43411 };
43412
43413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
43414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43415 if (SWIG_arg_fail(1)) SWIG_fail;
43416 {
43417 arg2 = (int)(SWIG_As_int(obj1));
43418 if (SWIG_arg_fail(2)) SWIG_fail;
43419 }
43420 {
43421 PyThreadState* __tstate = wxPyBeginAllowThreads();
43422 (arg1)->SetMargin(arg2);
43423
43424 wxPyEndAllowThreads(__tstate);
43425 if (PyErr_Occurred()) SWIG_fail;
43426 }
43427 Py_INCREF(Py_None); resultobj = Py_None;
43428 return resultobj;
43429 fail:
43430 return NULL;
43431 }
43432
43433
43434 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
43435 PyObject *resultobj;
43436 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43437 int result;
43438 PyObject * obj0 = 0 ;
43439 char *kwnames[] = {
43440 (char *) "self", NULL
43441 };
43442
43443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
43444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43445 if (SWIG_arg_fail(1)) SWIG_fail;
43446 {
43447 PyThreadState* __tstate = wxPyBeginAllowThreads();
43448 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
43449
43450 wxPyEndAllowThreads(__tstate);
43451 if (PyErr_Occurred()) SWIG_fail;
43452 }
43453 {
43454 resultobj = SWIG_From_int((int)(result));
43455 }
43456 return resultobj;
43457 fail:
43458 return NULL;
43459 }
43460
43461
43462 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
43463 PyObject *resultobj;
43464 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43465 int result;
43466 PyObject * obj0 = 0 ;
43467 char *kwnames[] = {
43468 (char *) "self", NULL
43469 };
43470
43471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
43472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43473 if (SWIG_arg_fail(1)) SWIG_fail;
43474 {
43475 PyThreadState* __tstate = wxPyBeginAllowThreads();
43476 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
43477
43478 wxPyEndAllowThreads(__tstate);
43479 if (PyErr_Occurred()) SWIG_fail;
43480 }
43481 {
43482 resultobj = SWIG_From_int((int)(result));
43483 }
43484 return resultobj;
43485 fail:
43486 return NULL;
43487 }
43488
43489
43490 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43491 PyObject *resultobj;
43492 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43493 int result;
43494 PyObject * obj0 = 0 ;
43495 char *kwnames[] = {
43496 (char *) "self", NULL
43497 };
43498
43499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
43500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43501 if (SWIG_arg_fail(1)) SWIG_fail;
43502 {
43503 PyThreadState* __tstate = wxPyBeginAllowThreads();
43504 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
43505
43506 wxPyEndAllowThreads(__tstate);
43507 if (PyErr_Occurred()) SWIG_fail;
43508 }
43509 {
43510 resultobj = SWIG_From_int((int)(result));
43511 }
43512 return resultobj;
43513 fail:
43514 return NULL;
43515 }
43516
43517
43518 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
43519 PyObject *resultobj;
43520 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43521 bool result;
43522 PyObject * obj0 = 0 ;
43523 char *kwnames[] = {
43524 (char *) "self", NULL
43525 };
43526
43527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
43528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43529 if (SWIG_arg_fail(1)) SWIG_fail;
43530 {
43531 PyThreadState* __tstate = wxPyBeginAllowThreads();
43532 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
43533
43534 wxPyEndAllowThreads(__tstate);
43535 if (PyErr_Occurred()) SWIG_fail;
43536 }
43537 {
43538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43539 }
43540 return resultobj;
43541 fail:
43542 return NULL;
43543 }
43544
43545
43546 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
43547 PyObject *resultobj;
43548 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43549 bool arg2 ;
43550 PyObject * obj0 = 0 ;
43551 PyObject * obj1 = 0 ;
43552 char *kwnames[] = {
43553 (char *) "self",(char *) "d", NULL
43554 };
43555
43556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
43557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43558 if (SWIG_arg_fail(1)) SWIG_fail;
43559 {
43560 arg2 = (bool)(SWIG_As_bool(obj1));
43561 if (SWIG_arg_fail(2)) SWIG_fail;
43562 }
43563 {
43564 PyThreadState* __tstate = wxPyBeginAllowThreads();
43565 (arg1)->SetDone(arg2);
43566
43567 wxPyEndAllowThreads(__tstate);
43568 if (PyErr_Occurred()) SWIG_fail;
43569 }
43570 Py_INCREF(Py_None); resultobj = Py_None;
43571 return resultobj;
43572 fail:
43573 return NULL;
43574 }
43575
43576
43577 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
43578 PyObject *resultobj;
43579 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43580 wxRelationship result;
43581 PyObject * obj0 = 0 ;
43582 char *kwnames[] = {
43583 (char *) "self", NULL
43584 };
43585
43586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
43587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43588 if (SWIG_arg_fail(1)) SWIG_fail;
43589 {
43590 PyThreadState* __tstate = wxPyBeginAllowThreads();
43591 result = (wxRelationship)(arg1)->GetRelationship();
43592
43593 wxPyEndAllowThreads(__tstate);
43594 if (PyErr_Occurred()) SWIG_fail;
43595 }
43596 resultobj = SWIG_From_int((result));
43597 return resultobj;
43598 fail:
43599 return NULL;
43600 }
43601
43602
43603 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
43604 PyObject *resultobj;
43605 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43606 wxRelationship arg2 ;
43607 PyObject * obj0 = 0 ;
43608 PyObject * obj1 = 0 ;
43609 char *kwnames[] = {
43610 (char *) "self",(char *) "r", NULL
43611 };
43612
43613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
43614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43615 if (SWIG_arg_fail(1)) SWIG_fail;
43616 {
43617 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43618 if (SWIG_arg_fail(2)) SWIG_fail;
43619 }
43620 {
43621 PyThreadState* __tstate = wxPyBeginAllowThreads();
43622 (arg1)->SetRelationship((wxRelationship )arg2);
43623
43624 wxPyEndAllowThreads(__tstate);
43625 if (PyErr_Occurred()) SWIG_fail;
43626 }
43627 Py_INCREF(Py_None); resultobj = Py_None;
43628 return resultobj;
43629 fail:
43630 return NULL;
43631 }
43632
43633
43634 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
43635 PyObject *resultobj;
43636 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43637 wxWindow *arg2 = (wxWindow *) 0 ;
43638 bool result;
43639 PyObject * obj0 = 0 ;
43640 PyObject * obj1 = 0 ;
43641 char *kwnames[] = {
43642 (char *) "self",(char *) "otherW", NULL
43643 };
43644
43645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
43646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43647 if (SWIG_arg_fail(1)) SWIG_fail;
43648 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43649 if (SWIG_arg_fail(2)) SWIG_fail;
43650 {
43651 PyThreadState* __tstate = wxPyBeginAllowThreads();
43652 result = (bool)(arg1)->ResetIfWin(arg2);
43653
43654 wxPyEndAllowThreads(__tstate);
43655 if (PyErr_Occurred()) SWIG_fail;
43656 }
43657 {
43658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43659 }
43660 return resultobj;
43661 fail:
43662 return NULL;
43663 }
43664
43665
43666 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
43667 PyObject *resultobj;
43668 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43669 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
43670 wxWindow *arg3 = (wxWindow *) 0 ;
43671 bool result;
43672 PyObject * obj0 = 0 ;
43673 PyObject * obj1 = 0 ;
43674 PyObject * obj2 = 0 ;
43675 char *kwnames[] = {
43676 (char *) "self",(char *) "constraints",(char *) "win", NULL
43677 };
43678
43679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
43680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43681 if (SWIG_arg_fail(1)) SWIG_fail;
43682 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43683 if (SWIG_arg_fail(2)) SWIG_fail;
43684 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43685 if (SWIG_arg_fail(3)) SWIG_fail;
43686 {
43687 PyThreadState* __tstate = wxPyBeginAllowThreads();
43688 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
43689
43690 wxPyEndAllowThreads(__tstate);
43691 if (PyErr_Occurred()) SWIG_fail;
43692 }
43693 {
43694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43695 }
43696 return resultobj;
43697 fail:
43698 return NULL;
43699 }
43700
43701
43702 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43703 PyObject *resultobj;
43704 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43705 wxEdge arg2 ;
43706 wxWindow *arg3 = (wxWindow *) 0 ;
43707 wxWindow *arg4 = (wxWindow *) 0 ;
43708 int result;
43709 PyObject * obj0 = 0 ;
43710 PyObject * obj1 = 0 ;
43711 PyObject * obj2 = 0 ;
43712 PyObject * obj3 = 0 ;
43713 char *kwnames[] = {
43714 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
43715 };
43716
43717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43719 if (SWIG_arg_fail(1)) SWIG_fail;
43720 {
43721 arg2 = (wxEdge)(SWIG_As_int(obj1));
43722 if (SWIG_arg_fail(2)) SWIG_fail;
43723 }
43724 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43725 if (SWIG_arg_fail(3)) SWIG_fail;
43726 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43727 if (SWIG_arg_fail(4)) SWIG_fail;
43728 {
43729 PyThreadState* __tstate = wxPyBeginAllowThreads();
43730 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
43731
43732 wxPyEndAllowThreads(__tstate);
43733 if (PyErr_Occurred()) SWIG_fail;
43734 }
43735 {
43736 resultobj = SWIG_From_int((int)(result));
43737 }
43738 return resultobj;
43739 fail:
43740 return NULL;
43741 }
43742
43743
43744 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
43745 PyObject *obj;
43746 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43747 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
43748 Py_INCREF(obj);
43749 return Py_BuildValue((char *)"");
43750 }
43751 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
43752 PyObject *resultobj;
43753 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43754 wxIndividualLayoutConstraint *result;
43755 PyObject * obj0 = 0 ;
43756 char *kwnames[] = {
43757 (char *) "self", NULL
43758 };
43759
43760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
43761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43762 if (SWIG_arg_fail(1)) SWIG_fail;
43763 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
43764
43765 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43766 return resultobj;
43767 fail:
43768 return NULL;
43769 }
43770
43771
43772 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
43773 PyObject *resultobj;
43774 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43775 wxIndividualLayoutConstraint *result;
43776 PyObject * obj0 = 0 ;
43777 char *kwnames[] = {
43778 (char *) "self", NULL
43779 };
43780
43781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
43782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43783 if (SWIG_arg_fail(1)) SWIG_fail;
43784 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
43785
43786 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43787 return resultobj;
43788 fail:
43789 return NULL;
43790 }
43791
43792
43793 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
43794 PyObject *resultobj;
43795 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43796 wxIndividualLayoutConstraint *result;
43797 PyObject * obj0 = 0 ;
43798 char *kwnames[] = {
43799 (char *) "self", NULL
43800 };
43801
43802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
43803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43804 if (SWIG_arg_fail(1)) SWIG_fail;
43805 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
43806
43807 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43808 return resultobj;
43809 fail:
43810 return NULL;
43811 }
43812
43813
43814 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
43815 PyObject *resultobj;
43816 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43817 wxIndividualLayoutConstraint *result;
43818 PyObject * obj0 = 0 ;
43819 char *kwnames[] = {
43820 (char *) "self", NULL
43821 };
43822
43823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
43824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43825 if (SWIG_arg_fail(1)) SWIG_fail;
43826 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
43827
43828 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43829 return resultobj;
43830 fail:
43831 return NULL;
43832 }
43833
43834
43835 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
43836 PyObject *resultobj;
43837 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43838 wxIndividualLayoutConstraint *result;
43839 PyObject * obj0 = 0 ;
43840 char *kwnames[] = {
43841 (char *) "self", NULL
43842 };
43843
43844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
43845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43846 if (SWIG_arg_fail(1)) SWIG_fail;
43847 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
43848
43849 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43850 return resultobj;
43851 fail:
43852 return NULL;
43853 }
43854
43855
43856 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
43857 PyObject *resultobj;
43858 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43859 wxIndividualLayoutConstraint *result;
43860 PyObject * obj0 = 0 ;
43861 char *kwnames[] = {
43862 (char *) "self", NULL
43863 };
43864
43865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
43866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43867 if (SWIG_arg_fail(1)) SWIG_fail;
43868 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
43869
43870 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43871 return resultobj;
43872 fail:
43873 return NULL;
43874 }
43875
43876
43877 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
43878 PyObject *resultobj;
43879 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43880 wxIndividualLayoutConstraint *result;
43881 PyObject * obj0 = 0 ;
43882 char *kwnames[] = {
43883 (char *) "self", NULL
43884 };
43885
43886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
43887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43888 if (SWIG_arg_fail(1)) SWIG_fail;
43889 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
43890
43891 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43892 return resultobj;
43893 fail:
43894 return NULL;
43895 }
43896
43897
43898 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
43899 PyObject *resultobj;
43900 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43901 wxIndividualLayoutConstraint *result;
43902 PyObject * obj0 = 0 ;
43903 char *kwnames[] = {
43904 (char *) "self", NULL
43905 };
43906
43907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
43908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43909 if (SWIG_arg_fail(1)) SWIG_fail;
43910 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
43911
43912 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43913 return resultobj;
43914 fail:
43915 return NULL;
43916 }
43917
43918
43919 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
43920 PyObject *resultobj;
43921 wxLayoutConstraints *result;
43922 char *kwnames[] = {
43923 NULL
43924 };
43925
43926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
43927 {
43928 PyThreadState* __tstate = wxPyBeginAllowThreads();
43929 result = (wxLayoutConstraints *)new wxLayoutConstraints();
43930
43931 wxPyEndAllowThreads(__tstate);
43932 if (PyErr_Occurred()) SWIG_fail;
43933 }
43934 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
43935 return resultobj;
43936 fail:
43937 return NULL;
43938 }
43939
43940
43941 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
43942 PyObject *resultobj;
43943 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43944 wxWindow *arg2 = (wxWindow *) 0 ;
43945 int *arg3 = (int *) 0 ;
43946 bool result;
43947 int temp3 ;
43948 int res3 = 0 ;
43949 PyObject * obj0 = 0 ;
43950 PyObject * obj1 = 0 ;
43951 char *kwnames[] = {
43952 (char *) "self",(char *) "win", NULL
43953 };
43954
43955 arg3 = &temp3; res3 = SWIG_NEWOBJ;
43956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
43957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43958 if (SWIG_arg_fail(1)) SWIG_fail;
43959 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43960 if (SWIG_arg_fail(2)) SWIG_fail;
43961 {
43962 PyThreadState* __tstate = wxPyBeginAllowThreads();
43963 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
43964
43965 wxPyEndAllowThreads(__tstate);
43966 if (PyErr_Occurred()) SWIG_fail;
43967 }
43968 {
43969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43970 }
43971 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
43972 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
43973 return resultobj;
43974 fail:
43975 return NULL;
43976 }
43977
43978
43979 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
43980 PyObject *resultobj;
43981 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43982 bool result;
43983 PyObject * obj0 = 0 ;
43984 char *kwnames[] = {
43985 (char *) "self", NULL
43986 };
43987
43988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
43989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43990 if (SWIG_arg_fail(1)) SWIG_fail;
43991 {
43992 PyThreadState* __tstate = wxPyBeginAllowThreads();
43993 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
43994
43995 wxPyEndAllowThreads(__tstate);
43996 if (PyErr_Occurred()) SWIG_fail;
43997 }
43998 {
43999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44000 }
44001 return resultobj;
44002 fail:
44003 return NULL;
44004 }
44005
44006
44007 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
44008 PyObject *obj;
44009 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44010 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
44011 Py_INCREF(obj);
44012 return Py_BuildValue((char *)"");
44013 }
44014 static PyMethodDef SwigMethods[] = {
44015 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
44016 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
44017 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44018 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44019 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
44020 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44021 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44022 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44023 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44024 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44025 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44026 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44027 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44028 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44029 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44030 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
44031 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
44032 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44033 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44034 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44035 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44036 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44037 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
44038 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
44039 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44040 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
44041 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44042 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44043 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44044 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44045 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44046 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44047 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44048 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44049 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44050 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44051 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44052 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44053 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
44054 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44055 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44056 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44057 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44058 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44059 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44060 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44061 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44062 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44063 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44064 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44065 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44066 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44067 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44068 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
44069 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44070 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
44071 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
44072 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
44073 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44074 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44075 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
44076 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44077 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
44078 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44079 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44080 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44081 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44082 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44083 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44084 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44085 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44086 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44087 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44088 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44089 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44090 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44091 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44092 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44093 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44094 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44095 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44096 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44097 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44098 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
44099 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
44100 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
44101 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
44102 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
44103 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
44104 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44105 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44106 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44107 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44108 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
44109 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
44110 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
44111 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44112 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44113 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44114 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44115 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44116 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44117 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44118 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44119 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44120 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44121 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
44122 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
44123 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
44124 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
44125 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44126 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
44127 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
44128 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44129 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44130 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44131 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44132 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
44133 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
44134 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44135 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44136 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
44137 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44138 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44139 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
44140 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
44141 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44142 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44143 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44144 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44145 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44146 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44147 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44148 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44149 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
44150 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44151 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44152 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
44153 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
44154 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
44155 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
44156 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
44157 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
44158 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
44159 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
44160 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
44161 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
44162 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
44163 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44164 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
44165 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
44166 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
44167 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
44168 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
44169 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
44170 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
44171 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44172 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44173 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
44174 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44175 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44176 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44177 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
44178 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
44179 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
44180 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44181 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44182 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44183 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44184 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44185 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44186 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
44187 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44188 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44189 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44190 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
44191 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
44192 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44193 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44194 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
44195 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
44196 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44197 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44198 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44199 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44200 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
44201 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
44202 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
44203 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
44204 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44205 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44206 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44207 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
44208 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44209 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44210 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44211 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44212 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44213 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
44214 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
44215 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44216 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
44217 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44218 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44219 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44220 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44221 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44222 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44223 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
44224 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44225 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44226 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
44227 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44228 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44229 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44230 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44231 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
44232 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44233 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
44234 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44235 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44236 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44237 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
44238 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44239 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44240 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
44241 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
44242 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
44243 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
44244 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44245 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
44246 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44247 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44248 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44249 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
44250 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
44251 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
44252 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
44253 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
44254 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44255 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44256 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44257 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44258 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44259 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44260 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
44261 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44262 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
44263 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44264 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
44265 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
44266 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44267 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44268 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44269 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44270 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44271 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
44272 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
44273 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44274 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44275 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44276 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
44277 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
44278 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
44279 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
44280 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
44281 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44282 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44283 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
44284 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
44285 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44286 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44287 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
44288 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
44289 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44290 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44291 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
44292 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
44293 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
44294 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
44295 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
44296 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
44297 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
44298 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
44299 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
44300 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
44301 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
44302 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
44303 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
44304 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44305 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44306 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44307 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44308 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
44309 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44310 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44311 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
44312 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44313 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
44314 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44315 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
44316 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44317 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
44318 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44319 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
44320 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44321 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
44322 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44323 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
44324 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44325 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
44326 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44327 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
44328 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44329 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
44330 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44331 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
44332 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44333 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
44334 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
44335 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
44336 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44337 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44338 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44339 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44340 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44341 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44342 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44343 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44344 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44345 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44346 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
44347 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
44348 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44349 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
44350 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44351 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
44352 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44353 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44354 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
44355 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
44356 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
44357 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
44358 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44359 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44360 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44361 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
44362 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
44363 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
44364 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
44365 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
44366 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44367 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
44368 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
44369 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
44370 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
44371 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
44372 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
44373 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
44374 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44375 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44376 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
44377 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
44378 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44379 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44380 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
44381 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
44382 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
44383 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
44384 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44385 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
44386 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44387 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
44388 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
44389 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
44390 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
44391 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44392 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44393 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44394 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44395 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44396 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
44397 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44398 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44399 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44400 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44401 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44402 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
44403 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44404 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
44405 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
44406 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44407 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
44408 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
44409 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44410 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
44411 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
44412 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
44413 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
44414 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44415 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
44416 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44417 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
44418 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
44419 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
44420 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
44421 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
44422 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44423 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44424 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44425 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44426 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44427 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44428 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
44429 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
44430 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
44431 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
44432 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44433 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44434 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44435 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44436 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44437 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
44438 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
44439 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
44440 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
44441 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44442 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44443 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44444 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44445 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44446 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44447 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44448 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44449 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44450 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44451 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44452 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44453 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44454 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44455 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44456 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44457 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44458 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44459 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
44460 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
44461 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
44462 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
44463 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
44464 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
44465 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
44466 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44467 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44468 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44469 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44470 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44471 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44472 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
44473 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44474 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
44475 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
44476 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
44477 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44478 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
44479 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
44480 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44481 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44482 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44483 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44484 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44485 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44486 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44487 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44488 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44489 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44490 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44491 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44492 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44493 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44494 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44495 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44496 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44497 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44498 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44499 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44500 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44501 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44502 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44503 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44504 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44505 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44506 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
44507 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
44508 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
44509 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44510 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44511 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44512 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44513 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44514 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
44515 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
44516 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
44517 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
44518 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
44519 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44520 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44521 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44522 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44523 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44524 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
44525 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44526 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
44527 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44528 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
44529 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44530 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
44531 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
44532 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44533 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44534 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44535 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
44536 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44537 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44538 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
44539 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44540 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44541 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
44542 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44543 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
44544 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44545 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
44546 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
44547 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44548 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
44549 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44550 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
44551 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
44552 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
44553 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44554 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44555 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44556 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
44557 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44558 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
44559 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
44560 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
44561 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44562 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
44563 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
44564 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44565 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
44566 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44567 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
44568 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
44569 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
44570 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44571 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44572 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44573 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
44574 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
44575 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44576 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44577 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44578 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44579 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
44580 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
44581 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
44582 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
44583 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
44584 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44585 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44586 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
44587 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44588 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
44589 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44590 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44591 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
44592 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44593 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
44594 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44595 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44596 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44597 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
44598 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44599 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
44600 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
44601 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
44602 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44603 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44604 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44605 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
44606 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
44607 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44608 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44609 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44610 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
44611 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44612 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44613 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
44614 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44615 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44616 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
44617 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44618 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44619 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44620 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
44621 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44622 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
44623 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
44624 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44625 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44626 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
44627 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
44628 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44629 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44630 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44631 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44632 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
44633 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44634 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44635 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44636 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44637 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
44638 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44639 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
44640 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
44641 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
44642 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
44643 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
44644 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44645 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
44646 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
44647 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44648 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44649 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
44650 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
44651 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
44652 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44653 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
44654 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44655 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
44656 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44657 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44658 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44659 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
44660 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
44661 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44662 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44663 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
44664 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44665 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44666 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
44667 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
44668 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
44669 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
44670 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
44671 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
44672 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
44673 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
44674 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
44675 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44676 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44677 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44678 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
44679 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
44680 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44681 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44682 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44683 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
44684 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
44685 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
44686 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
44687 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44688 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
44689 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
44690 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
44691 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44692 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44693 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
44694 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
44695 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
44696 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
44697 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44698 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44699 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
44700 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44701 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
44702 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
44703 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
44704 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44705 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44706 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
44707 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
44708 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
44709 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44710 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44711 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44712 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
44713 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
44714 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44715 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44716 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
44717 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
44718 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
44719 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44720 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44721 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
44722 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
44723 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
44724 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
44725 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
44726 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
44727 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
44728 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
44729 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44730 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44731 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
44732 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44733 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
44734 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
44735 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44736 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44737 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44738 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44739 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44740 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44741 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
44742 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
44743 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44744 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44745 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44746 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44747 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44748 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44749 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
44750 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44751 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44752 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
44753 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
44754 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
44755 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
44756 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
44757 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
44758 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44759 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44760 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44761 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44762 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44763 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44764 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44765 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
44766 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44767 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
44768 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44769 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44770 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44771 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44772 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
44773 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44774 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
44775 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
44776 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
44777 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
44778 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
44779 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44780 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
44781 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44782 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
44783 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
44784 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44785 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44786 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
44787 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44788 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44789 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44790 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44791 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44792 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44793 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44794 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44795 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44796 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
44797 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
44798 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44799 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
44800 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
44801 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44802 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44803 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44804 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44805 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
44806 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44807 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44808 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
44809 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44810 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44811 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44812 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
44813 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44814 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44815 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
44816 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44817 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44818 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44819 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
44820 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
44821 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
44822 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
44823 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
44824 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
44825 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
44826 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
44827 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
44828 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
44829 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
44830 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
44831 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44832 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44833 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44834 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44835 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44836 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
44837 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
44838 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
44839 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44840 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44841 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44842 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44843 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44844 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
44845 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
44846 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
44847 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
44848 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
44849 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
44850 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44851 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44852 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
44853 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
44854 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
44855 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
44856 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
44857 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
44858 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
44859 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
44860 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
44861 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
44862 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
44863 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
44864 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
44865 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44866 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
44867 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44868 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
44869 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44870 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44871 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44872 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44873 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44874 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44875 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44876 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44877 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44878 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44879 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
44880 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44881 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44882 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
44883 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
44884 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
44885 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
44886 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
44887 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44888 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44889 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
44890 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
44891 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
44892 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
44893 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
44894 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
44895 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
44896 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
44897 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
44898 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
44899 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
44900 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44901 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
44902 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
44903 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
44904 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
44905 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
44906 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
44907 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
44908 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
44909 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
44910 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44911 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
44912 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
44913 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
44914 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
44915 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
44916 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
44917 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
44918 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
44919 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
44920 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
44921 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
44922 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
44923 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
44924 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
44925 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
44926 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
44927 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
44928 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
44929 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
44930 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44931 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
44932 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44933 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44934 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44935 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44936 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
44937 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
44938 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
44939 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
44940 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44941 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
44942 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
44943 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44944 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
44945 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44946 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44947 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44948 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44949 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
44950 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
44951 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
44952 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
44953 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44954 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
44955 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
44956 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
44957 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44958 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
44959 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
44960 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44961 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
44962 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
44963 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
44964 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
44965 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44966 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
44967 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
44968 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44969 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
44970 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
44971 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44972 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
44973 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
44974 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44975 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
44976 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
44977 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
44978 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
44979 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44980 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
44981 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
44982 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
44983 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
44984 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
44985 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
44986 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44987 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44988 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44989 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44990 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44991 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44992 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44993 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
44994 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
44995 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44996 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44997 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44998 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44999 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45000 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45001 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45002 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
45003 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45004 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45005 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45006 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45007 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45008 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45009 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
45010 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45011 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45012 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45013 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
45014 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45015 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45016 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45017 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
45018 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
45019 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45020 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45021 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45022 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45023 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45024 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45025 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45026 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45027 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45028 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45029 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45030 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45031 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45032 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
45033 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45034 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45035 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45036 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
45037 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45038 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45039 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45040 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45041 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45042 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45043 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45044 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45045 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45046 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
45047 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45048 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45049 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45050 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45051 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45052 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45053 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45054 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45055 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45056 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45057 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45058 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
45059 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45060 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45061 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45062 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45063 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45064 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45065 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45066 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
45067 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
45068 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
45069 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45070 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
45071 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45072 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45073 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45074 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
45075 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45076 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
45077 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45078 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45079 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45080 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45081 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45082 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45083 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45084 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45085 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
45086 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45087 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
45088 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45089 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45090 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45091 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45092 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
45093 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
45094 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
45095 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45096 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45097 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45098 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45099 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45100 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45101 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45102 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45103 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45104 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45105 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45106 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
45107 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
45108 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
45109 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45110 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45111 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45112 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45113 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45114 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45115 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45116 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45117 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45118 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45119 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45120 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45121 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45122 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45123 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45124 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45125 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45126 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45127 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45128 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45129 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45130 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
45131 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
45132 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45133 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45134 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45135 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45136 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45137 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45138 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
45139 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45140 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45141 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45142 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45143 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45144 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45145 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45146 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45147 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45148 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
45149 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45150 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45151 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45152 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45153 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45154 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45155 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45156 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45157 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45158 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45159 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45160 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
45161 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
45162 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
45163 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45164 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
45165 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45166 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45167 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45168 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
45169 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45170 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
45171 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
45172 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45173 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45174 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45175 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45176 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45177 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45178 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45179 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45180 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45181 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
45182 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45183 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45184 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45185 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45186 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45187 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45188 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45189 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45190 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45191 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
45192 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
45193 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
45194 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45195 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
45196 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
45197 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45198 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45199 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45200 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45201 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
45202 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45203 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45204 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
45205 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
45206 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45207 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45208 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45209 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45210 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45211 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45212 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45213 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45214 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45215 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
45216 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45217 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45218 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45219 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45220 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45221 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45222 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45223 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45224 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45225 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
45226 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45227 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45228 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45229 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45230 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45231 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45232 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45233 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45234 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45235 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
45236 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
45237 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45238 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45239 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
45240 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45241 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45242 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45243 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45244 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45245 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
45247 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
45248 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
45249 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
45250 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
45251 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45252 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
45254 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
45255 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
45256 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
45258 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
45259 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
45261 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
45264 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45267 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45269 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
45274 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
45277 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
45279 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
45280 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
45281 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45282 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
45283 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
45284 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
45287 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
45295 { NULL, NULL, 0, NULL }
45296 };
45297
45298
45299 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
45300
45301 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
45302 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
45303 }
45304 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
45305 return (void *)((wxSizer *) ((wxBoxSizer *) x));
45306 }
45307 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
45308 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
45309 }
45310 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
45311 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45312 }
45313 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
45314 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
45315 }
45316 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
45317 return (void *)((wxSizer *) ((wxGridSizer *) x));
45318 }
45319 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
45320 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
45321 }
45322 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
45323 return (void *)((wxSizer *) ((wxPySizer *) x));
45324 }
45325 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
45326 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
45327 }
45328 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
45329 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45330 }
45331 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
45332 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
45333 }
45334 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
45335 return (void *)((wxEvent *) ((wxMenuEvent *) x));
45336 }
45337 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
45338 return (void *)((wxEvent *) ((wxCloseEvent *) x));
45339 }
45340 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
45341 return (void *)((wxEvent *) ((wxMouseEvent *) x));
45342 }
45343 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
45344 return (void *)((wxEvent *) ((wxEraseEvent *) x));
45345 }
45346 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
45347 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
45348 }
45349 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
45350 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
45351 }
45352 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
45353 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
45354 }
45355 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
45356 return (void *)((wxEvent *) ((wxPyEvent *) x));
45357 }
45358 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
45359 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
45360 }
45361 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
45362 return (void *)((wxEvent *) ((wxIdleEvent *) x));
45363 }
45364 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
45365 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
45366 }
45367 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
45368 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
45369 }
45370 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
45371 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
45372 }
45373 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
45374 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
45375 }
45376 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
45377 return (void *)((wxEvent *) ((wxActivateEvent *) x));
45378 }
45379 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
45380 return (void *)((wxEvent *) ((wxSizeEvent *) x));
45381 }
45382 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
45383 return (void *)((wxEvent *) ((wxMoveEvent *) x));
45384 }
45385 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
45386 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
45387 }
45388 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
45389 return (void *)((wxEvent *) ((wxPaintEvent *) x));
45390 }
45391 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
45392 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
45393 }
45394 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
45395 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
45396 }
45397 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
45398 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
45399 }
45400 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
45401 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
45402 }
45403 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
45404 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
45405 }
45406 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
45407 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
45408 }
45409 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
45410 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
45411 }
45412 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
45413 return (void *)((wxEvent *) ((wxFocusEvent *) x));
45414 }
45415 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
45416 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
45417 }
45418 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
45419 return (void *)((wxEvent *) ((wxShowEvent *) x));
45420 }
45421 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
45422 return (void *)((wxEvent *) ((wxCommandEvent *) x));
45423 }
45424 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
45425 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
45426 }
45427 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
45428 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45429 }
45430 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
45431 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
45432 }
45433 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
45434 return (void *)((wxEvent *) ((wxKeyEvent *) x));
45435 }
45436 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
45437 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
45438 }
45439 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
45440 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
45441 }
45442 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
45443 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
45444 }
45445 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
45446 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
45447 }
45448 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
45449 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
45450 }
45451 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
45452 return (void *)((wxControl *) ((wxControlWithItems *) x));
45453 }
45454 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
45455 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
45456 }
45457 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
45458 return (void *)((wxEvtHandler *) ((wxWindow *) x));
45459 }
45460 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
45461 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
45462 }
45463 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
45464 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
45465 }
45466 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
45467 return (void *)((wxEvtHandler *) ((wxValidator *) x));
45468 }
45469 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
45470 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
45471 }
45472 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
45473 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
45474 }
45475 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
45476 return (void *)((wxEvtHandler *) ((wxMenu *) x));
45477 }
45478 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
45479 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
45480 }
45481 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
45482 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
45483 }
45484 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
45485 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
45486 }
45487 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
45488 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
45489 }
45490 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
45491 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
45492 }
45493 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
45494 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45495 }
45496 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
45497 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
45498 }
45499 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
45500 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
45501 }
45502 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
45503 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
45504 }
45505 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
45506 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45507 }
45508 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
45509 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
45510 }
45511 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
45512 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
45513 }
45514 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
45515 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
45516 }
45517 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
45518 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
45519 }
45520 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
45521 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
45522 }
45523 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
45524 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
45525 }
45526 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
45527 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
45528 }
45529 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
45530 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
45531 }
45532 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
45533 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
45534 }
45535 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
45536 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
45537 }
45538 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
45539 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
45540 }
45541 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
45542 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
45543 }
45544 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
45545 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
45546 }
45547 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
45548 return (void *)((wxObject *) ((wxSizerItem *) x));
45549 }
45550 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
45551 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
45552 }
45553 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
45554 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
45555 }
45556 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
45557 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
45558 }
45559 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
45560 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
45561 }
45562 static void *_p_wxSizerTo_p_wxObject(void *x) {
45563 return (void *)((wxObject *) ((wxSizer *) x));
45564 }
45565 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
45566 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
45567 }
45568 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
45569 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
45570 }
45571 static void *_p_wxEventTo_p_wxObject(void *x) {
45572 return (void *)((wxObject *) ((wxEvent *) x));
45573 }
45574 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
45575 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
45576 }
45577 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
45578 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
45579 }
45580 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
45581 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
45582 }
45583 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
45584 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
45585 }
45586 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
45587 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
45588 }
45589 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
45590 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
45591 }
45592 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
45593 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
45594 }
45595 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
45596 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
45597 }
45598 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
45599 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
45600 }
45601 static void *_p_wxControlTo_p_wxObject(void *x) {
45602 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
45603 }
45604 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
45605 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
45606 }
45607 static void *_p_wxFSFileTo_p_wxObject(void *x) {
45608 return (void *)((wxObject *) ((wxFSFile *) x));
45609 }
45610 static void *_p_wxPySizerTo_p_wxObject(void *x) {
45611 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
45612 }
45613 static void *_p_wxPyEventTo_p_wxObject(void *x) {
45614 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
45615 }
45616 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
45617 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
45618 }
45619 static void *_p_wxShowEventTo_p_wxObject(void *x) {
45620 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
45621 }
45622 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
45623 return (void *)((wxObject *) ((wxMenuItem *) x));
45624 }
45625 static void *_p_wxDateEventTo_p_wxObject(void *x) {
45626 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
45627 }
45628 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
45629 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
45630 }
45631 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
45632 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
45633 }
45634 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
45635 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
45636 }
45637 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
45638 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
45639 }
45640 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
45641 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
45642 }
45643 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
45644 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
45645 }
45646 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
45647 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
45648 }
45649 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
45650 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
45651 }
45652 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
45653 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
45654 }
45655 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
45656 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
45657 }
45658 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
45659 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
45660 }
45661 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
45662 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
45663 }
45664 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
45665 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
45666 }
45667 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
45668 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
45669 }
45670 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
45671 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45672 }
45673 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
45674 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
45675 }
45676 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
45677 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
45678 }
45679 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
45680 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
45681 }
45682 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
45683 return (void *)((wxObject *) ((wxImageHandler *) x));
45684 }
45685 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
45686 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
45687 }
45688 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
45689 return (void *)((wxObject *) ((wxEvtHandler *) x));
45690 }
45691 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
45692 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45693 }
45694 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
45695 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
45696 }
45697 static void *_p_wxImageTo_p_wxObject(void *x) {
45698 return (void *)((wxObject *) ((wxImage *) x));
45699 }
45700 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
45701 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
45702 }
45703 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
45704 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45705 }
45706 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
45707 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
45708 }
45709 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
45710 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
45711 }
45712 static void *_p_wxWindowTo_p_wxObject(void *x) {
45713 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
45714 }
45715 static void *_p_wxMenuTo_p_wxObject(void *x) {
45716 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
45717 }
45718 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
45719 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
45720 }
45721 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
45722 return (void *)((wxObject *) ((wxFileSystem *) x));
45723 }
45724 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
45725 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
45726 }
45727 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
45728 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
45729 }
45730 static void *_p_wxPyAppTo_p_wxObject(void *x) {
45731 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
45732 }
45733 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
45734 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
45735 }
45736 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
45737 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
45738 }
45739 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
45740 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
45741 }
45742 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
45743 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
45744 }
45745 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
45746 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
45747 }
45748 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
45749 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
45750 }
45751 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
45752 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
45753 }
45754 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
45755 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
45756 }
45757 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
45758 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
45759 }
45760 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
45761 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
45762 }
45763 static void *_p_wxValidatorTo_p_wxObject(void *x) {
45764 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
45765 }
45766 static void *_p_wxControlTo_p_wxWindow(void *x) {
45767 return (void *)((wxWindow *) ((wxControl *) x));
45768 }
45769 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
45770 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
45771 }
45772 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
45773 return (void *)((wxWindow *) ((wxMenuBar *) x));
45774 }
45775 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
45776 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
45777 }
45778 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
45779 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
45780 }
45781 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
45782 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
45783 }
45784 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
45785 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
45786 }
45787 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
45788 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
45789 }
45790 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
45791 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45792 }
45793 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
45794 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
45795 }
45796 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
45797 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
45798 }
45799 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
45800 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
45801 }
45802 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
45803 return (void *)((wxValidator *) ((wxPyValidator *) x));
45804 }
45805 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}};
45806 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}};
45807 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}};
45808 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}};
45809 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}};
45810 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}};
45811 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}};
45812 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}};
45813 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}};
45814 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}};
45815 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}};
45816 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}};
45817 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}};
45818 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
45819 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}};
45820 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}};
45821 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}};
45822 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}};
45823 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}};
45824 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}};
45825 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}};
45826 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}};
45827 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}};
45828 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}};
45829 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}};
45830 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}};
45831 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}};
45832 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}};
45833 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}};
45834 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}};
45835 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}};
45836 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}};
45837 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}};
45838 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}};
45839 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}};
45840 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}};
45841 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}};
45842 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}};
45843 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}};
45844 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}};
45845 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}};
45846 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}};
45847 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}};
45848 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}};
45849 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}};
45850 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}};
45851 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}};
45852 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}};
45853 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}};
45854 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}};
45855 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}};
45856 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}};
45857 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}};
45858 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}};
45859 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}};
45860 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}};
45861 static swig_type_info _swigt__p_wxDateEvent[] = {{"_p_wxDateEvent", 0, "wxDateEvent *", 0, 0, 0, 0},{"_p_wxDateEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
45862 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}};
45863 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}};
45864 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}};
45865 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}};
45866 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}};
45867 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}};
45868 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}};
45869 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}};
45870 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}};
45871 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}};
45872 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}};
45873 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}};
45874 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}};
45875 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}};
45876 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}};
45877 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}};
45878 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}};
45879 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}};
45880 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}};
45881 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}};
45882 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}};
45883 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}};
45884 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}};
45885 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}};
45886 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}};
45887 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}};
45888 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}};
45889 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}};
45890 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}};
45891 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}};
45892 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}};
45893 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}};
45894 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}};
45895 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}};
45896 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}};
45897 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}};
45898 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}};
45899 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
45900 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}};
45901 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}};
45902 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}};
45903 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}};
45904 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}};
45905 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}};
45906 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}};
45907 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}};
45908 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}};
45909 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}};
45910 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}};
45911 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}};
45912 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}};
45913 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}};
45914 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}};
45915 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}};
45916 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}};
45917 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}};
45918 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}};
45919 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}};
45920 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}};
45921 static swig_type_info _swigt__p_wxCommandEvent[] = {{"_p_wxCommandEvent", 0, "wxCommandEvent *", 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", 0, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
45922 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}};
45923 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}};
45924 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}};
45925 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}};
45926 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}};
45927 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}};
45928 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}};
45929 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}};
45930 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}};
45931 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}};
45932
45933 static swig_type_info *swig_types_initial[] = {
45934 _swigt__p_wxLayoutConstraints,
45935 _swigt__p_wxRealPoint,
45936 _swigt__p_wxSizerItem,
45937 _swigt__p_wxGBSizerItem,
45938 _swigt__p_wxScrollEvent,
45939 _swigt__p_wxEventLoop,
45940 _swigt__p_wxIndividualLayoutConstraint,
45941 _swigt__p_wxSizer,
45942 _swigt__p_wxBoxSizer,
45943 _swigt__p_wxStaticBoxSizer,
45944 _swigt__p_wxGridBagSizer,
45945 _swigt__p_wxAcceleratorEntry,
45946 _swigt__p_wxUpdateUIEvent,
45947 _swigt__p_wxEvent,
45948 _swigt__p_wxMenu,
45949 _swigt__p_wxGridSizer,
45950 _swigt__p_wxFlexGridSizer,
45951 _swigt__p_wxInitDialogEvent,
45952 _swigt__p_wxItemContainer,
45953 _swigt__p_wxNcPaintEvent,
45954 _swigt__p_wxPaintEvent,
45955 _swigt__p_wxSysColourChangedEvent,
45956 _swigt__p_wxMouseCaptureChangedEvent,
45957 _swigt__p_wxDisplayChangedEvent,
45958 _swigt__p_wxPaletteChangedEvent,
45959 _swigt__p_wxControl,
45960 _swigt__p_wxFont,
45961 _swigt__p_wxMenuBarBase,
45962 _swigt__p_wxSetCursorEvent,
45963 _swigt__p_wxFSFile,
45964 _swigt__p_wxCaret,
45965 _swigt__ptrdiff_t,
45966 _swigt__std__ptrdiff_t,
45967 _swigt__p_wxRegion,
45968 _swigt__p_wxPoint2D,
45969 _swigt__p_int,
45970 _swigt__p_wxSize,
45971 _swigt__p_wxDC,
45972 _swigt__p_wxPySizer,
45973 _swigt__p_wxVisualAttributes,
45974 _swigt__p_wxNotifyEvent,
45975 _swigt__p_wxPyEvent,
45976 _swigt__p_wxPropagationDisabler,
45977 _swigt__p_form_ops_t,
45978 _swigt__p_wxAppTraits,
45979 _swigt__p_wxArrayString,
45980 _swigt__p_wxShowEvent,
45981 _swigt__p_wxToolTip,
45982 _swigt__p_wxMoveEvent,
45983 _swigt__p_wxSizeEvent,
45984 _swigt__p_wxActivateEvent,
45985 _swigt__p_wxIconizeEvent,
45986 _swigt__p_wxMaximizeEvent,
45987 _swigt__p_wxQueryNewPaletteEvent,
45988 _swigt__p_wxWindowCreateEvent,
45989 _swigt__p_wxIdleEvent,
45990 _swigt__p_wxDateEvent,
45991 _swigt__p_wxMenuItem,
45992 _swigt__p_wxStaticBox,
45993 _swigt__p_long,
45994 _swigt__p_wxDuplexMode,
45995 _swigt__p_wxTIFFHandler,
45996 _swigt__p_wxXPMHandler,
45997 _swigt__p_wxPNMHandler,
45998 _swigt__p_wxJPEGHandler,
45999 _swigt__p_wxPCXHandler,
46000 _swigt__p_wxGIFHandler,
46001 _swigt__p_wxPNGHandler,
46002 _swigt__p_wxANIHandler,
46003 _swigt__p_wxMemoryFSHandler,
46004 _swigt__p_wxZipFSHandler,
46005 _swigt__p_wxInternetFSHandler,
46006 _swigt__p_wxPyFileSystemHandler,
46007 _swigt__p_wxEvtHandler,
46008 _swigt__p_wxCURHandler,
46009 _swigt__p_wxICOHandler,
46010 _swigt__p_wxBMPHandler,
46011 _swigt__p_wxImageHandler,
46012 _swigt__p_wxFileSystemHandler,
46013 _swigt__p_wxRect,
46014 _swigt__p_wxButton,
46015 _swigt__p_wxGBSpan,
46016 _swigt__p_wxPropagateOnce,
46017 _swigt__p_wxAcceleratorTable,
46018 _swigt__p_wxStdDialogButtonSizer,
46019 _swigt__p_char,
46020 _swigt__p_wxGBPosition,
46021 _swigt__p_wxImage,
46022 _swigt__p_wxFrame,
46023 _swigt__p_wxScrollWinEvent,
46024 _swigt__p_wxPaperSize,
46025 _swigt__p_wxImageHistogram,
46026 _swigt__p_wxPoint,
46027 _swigt__p_wxCursor,
46028 _swigt__p_wxObject,
46029 _swigt__p_wxInputStream,
46030 _swigt__p_wxOutputStream,
46031 _swigt__p_wxPyInputStream,
46032 _swigt__p_wxDateTime,
46033 _swigt__p_wxKeyEvent,
46034 _swigt__p_wxNavigationKeyEvent,
46035 _swigt__p_wxWindowDestroyEvent,
46036 _swigt__p_unsigned_long,
46037 _swigt__p_wxWindow,
46038 _swigt__p_wxMenuBar,
46039 _swigt__p_wxFileSystem,
46040 _swigt__p_wxBitmap,
46041 _swigt__unsigned_int,
46042 _swigt__p_unsigned_int,
46043 _swigt__p_wxMenuEvent,
46044 _swigt__p_wxContextMenuEvent,
46045 _swigt__p_unsigned_char,
46046 _swigt__p_wxEraseEvent,
46047 _swigt__p_wxMouseEvent,
46048 _swigt__p_wxCloseEvent,
46049 _swigt__p_wxPyApp,
46050 _swigt__p_wxCommandEvent,
46051 _swigt__p_wxPyCommandEvent,
46052 _swigt__p_wxPyDropTarget,
46053 _swigt__p_wxQuantize,
46054 _swigt__p_wxChildFocusEvent,
46055 _swigt__p_wxFocusEvent,
46056 _swigt__p_wxDropFilesEvent,
46057 _swigt__p_wxControlWithItems,
46058 _swigt__p_wxColour,
46059 _swigt__p_wxValidator,
46060 _swigt__p_wxPyValidator,
46061 0
46062 };
46063
46064
46065 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
46066
46067 static swig_const_info swig_const_table[] = {
46068 {0, 0, 0, 0.0, 0, 0}};
46069
46070 #ifdef __cplusplus
46071 }
46072 #endif
46073
46074
46075 #ifdef __cplusplus
46076 extern "C" {
46077 #endif
46078
46079 /* Python-specific SWIG API */
46080 #define SWIG_newvarlink() SWIG_Python_newvarlink()
46081 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
46082 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
46083
46084 /* -----------------------------------------------------------------------------
46085 * global variable support code.
46086 * ----------------------------------------------------------------------------- */
46087
46088 typedef struct swig_globalvar {
46089 char *name; /* Name of global variable */
46090 PyObject *(*get_attr)(); /* Return the current value */
46091 int (*set_attr)(PyObject *); /* Set the value */
46092 struct swig_globalvar *next;
46093 } swig_globalvar;
46094
46095 typedef struct swig_varlinkobject {
46096 PyObject_HEAD
46097 swig_globalvar *vars;
46098 } swig_varlinkobject;
46099
46100 static PyObject *
46101 swig_varlink_repr(swig_varlinkobject *v) {
46102 v = v;
46103 return PyString_FromString("<Swig global variables>");
46104 }
46105
46106 static int
46107 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
46108 swig_globalvar *var;
46109 flags = flags;
46110 fprintf(fp,"Swig global variables { ");
46111 for (var = v->vars; var; var=var->next) {
46112 fprintf(fp,"%s", var->name);
46113 if (var->next) fprintf(fp,", ");
46114 }
46115 fprintf(fp," }\n");
46116 return 0;
46117 }
46118
46119 static PyObject *
46120 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
46121 swig_globalvar *var = v->vars;
46122 while (var) {
46123 if (strcmp(var->name,n) == 0) {
46124 return (*var->get_attr)();
46125 }
46126 var = var->next;
46127 }
46128 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46129 return NULL;
46130 }
46131
46132 static int
46133 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
46134 swig_globalvar *var = v->vars;
46135 while (var) {
46136 if (strcmp(var->name,n) == 0) {
46137 return (*var->set_attr)(p);
46138 }
46139 var = var->next;
46140 }
46141 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46142 return 1;
46143 }
46144
46145 static PyTypeObject varlinktype = {
46146 PyObject_HEAD_INIT(0)
46147 0, /* Number of items in variable part (ob_size) */
46148 (char *)"swigvarlink", /* Type name (tp_name) */
46149 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
46150 0, /* Itemsize (tp_itemsize) */
46151 0, /* Deallocator (tp_dealloc) */
46152 (printfunc) swig_varlink_print, /* Print (tp_print) */
46153 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
46154 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
46155 0, /* tp_compare */
46156 (reprfunc) swig_varlink_repr, /* tp_repr */
46157 0, /* tp_as_number */
46158 0, /* tp_as_sequence */
46159 0, /* tp_as_mapping */
46160 0, /* tp_hash */
46161 0, /* tp_call */
46162 0, /* tp_str */
46163 0, /* tp_getattro */
46164 0, /* tp_setattro */
46165 0, /* tp_as_buffer */
46166 0, /* tp_flags */
46167 0, /* tp_doc */
46168 #if PY_VERSION_HEX >= 0x02000000
46169 0, /* tp_traverse */
46170 0, /* tp_clear */
46171 #endif
46172 #if PY_VERSION_HEX >= 0x02010000
46173 0, /* tp_richcompare */
46174 0, /* tp_weaklistoffset */
46175 #endif
46176 #if PY_VERSION_HEX >= 0x02020000
46177 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
46178 #endif
46179 #if PY_VERSION_HEX >= 0x02030000
46180 0, /* tp_del */
46181 #endif
46182 #ifdef COUNT_ALLOCS
46183 0,0,0,0 /* tp_alloc -> tp_next */
46184 #endif
46185 };
46186
46187 /* Create a variable linking object for use later */
46188 static PyObject *
46189 SWIG_Python_newvarlink(void) {
46190 swig_varlinkobject *result = 0;
46191 result = PyMem_NEW(swig_varlinkobject,1);
46192 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
46193 result->ob_type = &varlinktype;
46194 result->vars = 0;
46195 result->ob_refcnt = 0;
46196 Py_XINCREF((PyObject *) result);
46197 return ((PyObject*) result);
46198 }
46199
46200 static void
46201 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
46202 swig_varlinkobject *v;
46203 swig_globalvar *gv;
46204 v= (swig_varlinkobject *) p;
46205 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
46206 gv->name = (char *) malloc(strlen(name)+1);
46207 strcpy(gv->name,name);
46208 gv->get_attr = get_attr;
46209 gv->set_attr = set_attr;
46210 gv->next = v->vars;
46211 v->vars = gv;
46212 }
46213
46214 /* -----------------------------------------------------------------------------
46215 * constants/methods manipulation
46216 * ----------------------------------------------------------------------------- */
46217
46218 /* Install Constants */
46219 static void
46220 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
46221 PyObject *obj = 0;
46222 size_t i;
46223 for (i = 0; constants[i].type; i++) {
46224 switch(constants[i].type) {
46225 case SWIG_PY_INT:
46226 obj = PyInt_FromLong(constants[i].lvalue);
46227 break;
46228 case SWIG_PY_FLOAT:
46229 obj = PyFloat_FromDouble(constants[i].dvalue);
46230 break;
46231 case SWIG_PY_STRING:
46232 if (constants[i].pvalue) {
46233 obj = PyString_FromString((char *) constants[i].pvalue);
46234 } else {
46235 Py_INCREF(Py_None);
46236 obj = Py_None;
46237 }
46238 break;
46239 case SWIG_PY_POINTER:
46240 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
46241 break;
46242 case SWIG_PY_BINARY:
46243 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
46244 break;
46245 default:
46246 obj = 0;
46247 break;
46248 }
46249 if (obj) {
46250 PyDict_SetItemString(d,constants[i].name,obj);
46251 Py_DECREF(obj);
46252 }
46253 }
46254 }
46255
46256 /* -----------------------------------------------------------------------------*/
46257 /* Fix SwigMethods to carry the callback ptrs when needed */
46258 /* -----------------------------------------------------------------------------*/
46259
46260 static void
46261 SWIG_Python_FixMethods(PyMethodDef *methods,
46262 swig_const_info *const_table,
46263 swig_type_info **types,
46264 swig_type_info **types_initial) {
46265 size_t i;
46266 for (i = 0; methods[i].ml_name; ++i) {
46267 char *c = methods[i].ml_doc;
46268 if (c && (c = strstr(c, "swig_ptr: "))) {
46269 int j;
46270 swig_const_info *ci = 0;
46271 char *name = c + 10;
46272 for (j = 0; const_table[j].type; j++) {
46273 if (strncmp(const_table[j].name, name,
46274 strlen(const_table[j].name)) == 0) {
46275 ci = &(const_table[j]);
46276 break;
46277 }
46278 }
46279 if (ci) {
46280 size_t shift = (ci->ptype) - types;
46281 swig_type_info *ty = types_initial[shift];
46282 size_t ldoc = (c - methods[i].ml_doc);
46283 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
46284 char *ndoc = (char*)malloc(ldoc + lptr + 10);
46285 char *buff = ndoc;
46286 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
46287 strncpy(buff, methods[i].ml_doc, ldoc);
46288 buff += ldoc;
46289 strncpy(buff, "swig_ptr: ", 10);
46290 buff += 10;
46291 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
46292 methods[i].ml_doc = ndoc;
46293 }
46294 }
46295 }
46296 }
46297
46298 /* -----------------------------------------------------------------------------*
46299 * Initialize type list
46300 * -----------------------------------------------------------------------------*/
46301
46302 #if PY_MAJOR_VERSION < 2
46303 /* PyModule_AddObject function was introduced in Python 2.0. The following function
46304 is copied out of Python/modsupport.c in python version 2.3.4 */
46305 static int
46306 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
46307 {
46308 PyObject *dict;
46309 if (!PyModule_Check(m)) {
46310 PyErr_SetString(PyExc_TypeError,
46311 "PyModule_AddObject() needs module as first arg");
46312 return -1;
46313 }
46314 if (!o) {
46315 PyErr_SetString(PyExc_TypeError,
46316 "PyModule_AddObject() needs non-NULL value");
46317 return -1;
46318 }
46319
46320 dict = PyModule_GetDict(m);
46321 if (dict == NULL) {
46322 /* Internal error -- modules must have a dict! */
46323 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
46324 PyModule_GetName(m));
46325 return -1;
46326 }
46327 if (PyDict_SetItemString(dict, name, o))
46328 return -1;
46329 Py_DECREF(o);
46330 return 0;
46331 }
46332 #endif
46333
46334 static swig_type_info **
46335 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
46336 static PyMethodDef swig_empty_runtime_method_table[] = {
46337 {
46338 NULL, NULL, 0, NULL
46339 }
46340 };/* Sentinel */
46341
46342 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
46343 swig_empty_runtime_method_table);
46344 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
46345 if (pointer && module) {
46346 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
46347 }
46348 return type_list_handle;
46349 }
46350
46351 static swig_type_info **
46352 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
46353 swig_type_info **type_pointer;
46354
46355 /* first check if module already created */
46356 type_pointer = SWIG_Python_GetTypeListHandle();
46357 if (type_pointer) {
46358 return type_pointer;
46359 } else {
46360 /* create a new module and variable */
46361 return SWIG_Python_SetTypeListHandle(type_list_handle);
46362 }
46363 }
46364
46365 #ifdef __cplusplus
46366 }
46367 #endif
46368
46369 /* -----------------------------------------------------------------------------*
46370 * Partial Init method
46371 * -----------------------------------------------------------------------------*/
46372
46373 #ifdef SWIG_LINK_RUNTIME
46374 #ifdef __cplusplus
46375 extern "C"
46376 #endif
46377 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
46378 #endif
46379
46380 #ifdef __cplusplus
46381 extern "C"
46382 #endif
46383 SWIGEXPORT(void) SWIG_init(void) {
46384 static PyObject *SWIG_globals = 0;
46385 static int typeinit = 0;
46386 PyObject *m, *d;
46387 int i;
46388 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
46389
46390 /* Fix SwigMethods to carry the callback ptrs when needed */
46391 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
46392
46393 m = Py_InitModule((char *) SWIG_name, SwigMethods);
46394 d = PyModule_GetDict(m);
46395
46396 if (!typeinit) {
46397 #ifdef SWIG_LINK_RUNTIME
46398 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
46399 #else
46400 # ifndef SWIG_STATIC_RUNTIME
46401 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
46402 # endif
46403 #endif
46404 for (i = 0; swig_types_initial[i]; i++) {
46405 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
46406 }
46407 typeinit = 1;
46408 }
46409 SWIG_InstallConstants(d,swig_const_table);
46410
46411
46412 #ifndef wxPyUSE_EXPORT
46413 // Make our API structure a CObject so other modules can import it
46414 // from this module.
46415 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
46416 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
46417 Py_XDECREF(cobj);
46418 #endif
46419
46420 {
46421 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
46422 }
46423 {
46424 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
46425 }
46426 {
46427 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
46428 }
46429 {
46430 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
46431 }
46432 {
46433 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
46434 }
46435 {
46436 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
46437 }
46438 {
46439 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
46440 }
46441 {
46442 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
46443 }
46444 {
46445 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
46446 }
46447 {
46448 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
46449 }
46450 {
46451 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
46452 }
46453 {
46454 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
46455 }
46456 {
46457 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
46458 }
46459 {
46460 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
46461 }
46462 {
46463 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
46464 }
46465 {
46466 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
46467 }
46468 {
46469 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
46470 }
46471 {
46472 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
46473 }
46474 {
46475 PyDict_SetItemString(d,"ED_CLIENT_MARGIN", SWIG_From_int((int)(wxED_CLIENT_MARGIN)));
46476 }
46477 {
46478 PyDict_SetItemString(d,"ED_BUTTONS_BOTTOM", SWIG_From_int((int)(wxED_BUTTONS_BOTTOM)));
46479 }
46480 {
46481 PyDict_SetItemString(d,"ED_BUTTONS_RIGHT", SWIG_From_int((int)(wxED_BUTTONS_RIGHT)));
46482 }
46483 {
46484 PyDict_SetItemString(d,"ED_STATIC_LINE", SWIG_From_int((int)(wxED_STATIC_LINE)));
46485 }
46486 {
46487 PyDict_SetItemString(d,"EXT_DIALOG_STYLE", SWIG_From_int((int)(wxEXT_DIALOG_STYLE)));
46488 }
46489 {
46490 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
46491 }
46492 {
46493 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
46494 }
46495 {
46496 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
46497 }
46498 {
46499 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
46500 }
46501 {
46502 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
46503 }
46504 {
46505 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
46506 }
46507 {
46508 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
46509 }
46510 {
46511 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
46512 }
46513 {
46514 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
46515 }
46516 {
46517 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
46518 }
46519 {
46520 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
46521 }
46522 {
46523 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
46524 }
46525 {
46526 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
46527 }
46528 {
46529 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
46530 }
46531 {
46532 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
46533 }
46534 {
46535 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
46536 }
46537 {
46538 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
46539 }
46540 {
46541 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
46542 }
46543 {
46544 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
46545 }
46546 {
46547 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
46548 }
46549 {
46550 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
46551 }
46552 {
46553 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
46554 }
46555 {
46556 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
46557 }
46558 {
46559 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
46560 }
46561 {
46562 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
46563 }
46564 {
46565 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
46566 }
46567 {
46568 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
46569 }
46570 {
46571 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
46572 }
46573 {
46574 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
46575 }
46576 {
46577 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
46578 }
46579 {
46580 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
46581 }
46582 {
46583 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
46584 }
46585 {
46586 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
46587 }
46588 {
46589 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
46590 }
46591 {
46592 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
46593 }
46594 {
46595 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
46596 }
46597 {
46598 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
46599 }
46600 {
46601 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
46602 }
46603 {
46604 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
46605 }
46606 {
46607 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
46608 }
46609 {
46610 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
46611 }
46612 {
46613 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
46614 }
46615 {
46616 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
46617 }
46618 {
46619 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
46620 }
46621 {
46622 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
46623 }
46624 {
46625 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
46626 }
46627 {
46628 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
46629 }
46630 {
46631 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
46632 }
46633 {
46634 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
46635 }
46636 {
46637 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
46638 }
46639 {
46640 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
46641 }
46642 {
46643 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
46644 }
46645 {
46646 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
46647 }
46648 {
46649 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
46650 }
46651 {
46652 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
46653 }
46654 {
46655 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
46656 }
46657 {
46658 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
46659 }
46660 {
46661 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
46662 }
46663 {
46664 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
46665 }
46666 {
46667 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
46668 }
46669 {
46670 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
46671 }
46672 {
46673 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
46674 }
46675 {
46676 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
46677 }
46678 {
46679 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
46680 }
46681 {
46682 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
46683 }
46684 {
46685 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
46686 }
46687 {
46688 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
46689 }
46690 {
46691 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
46692 }
46693 {
46694 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
46695 }
46696 {
46697 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
46698 }
46699 {
46700 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
46701 }
46702 {
46703 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
46704 }
46705 {
46706 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
46707 }
46708 {
46709 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
46710 }
46711 {
46712 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
46713 }
46714 {
46715 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
46716 }
46717 {
46718 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
46719 }
46720 {
46721 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
46722 }
46723 {
46724 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
46725 }
46726 {
46727 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
46728 }
46729 {
46730 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
46731 }
46732 {
46733 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
46734 }
46735 {
46736 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
46737 }
46738 {
46739 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
46740 }
46741 {
46742 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
46743 }
46744 {
46745 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
46746 }
46747 {
46748 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
46749 }
46750 {
46751 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
46752 }
46753 {
46754 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
46755 }
46756 {
46757 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
46758 }
46759 {
46760 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
46761 }
46762 {
46763 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
46764 }
46765 {
46766 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
46767 }
46768 {
46769 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
46770 }
46771 {
46772 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
46773 }
46774 {
46775 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
46776 }
46777 {
46778 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
46779 }
46780 {
46781 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
46782 }
46783 {
46784 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
46785 }
46786 {
46787 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
46788 }
46789 {
46790 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
46791 }
46792 {
46793 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
46794 }
46795 {
46796 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
46797 }
46798 {
46799 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
46800 }
46801 {
46802 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
46803 }
46804 {
46805 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
46806 }
46807 {
46808 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
46809 }
46810 {
46811 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
46812 }
46813 {
46814 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
46815 }
46816 {
46817 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
46818 }
46819 {
46820 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
46821 }
46822 {
46823 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
46824 }
46825 {
46826 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
46827 }
46828 {
46829 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
46830 }
46831 {
46832 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
46833 }
46834 {
46835 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
46836 }
46837 {
46838 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
46839 }
46840 {
46841 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
46842 }
46843 {
46844 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
46845 }
46846 {
46847 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
46848 }
46849 {
46850 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
46851 }
46852 {
46853 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
46854 }
46855 {
46856 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
46857 }
46858 {
46859 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
46860 }
46861 {
46862 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
46863 }
46864 {
46865 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
46866 }
46867 {
46868 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
46869 }
46870 {
46871 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
46872 }
46873 {
46874 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
46875 }
46876 {
46877 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
46878 }
46879 {
46880 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
46881 }
46882 {
46883 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
46884 }
46885 {
46886 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
46887 }
46888 {
46889 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
46890 }
46891 {
46892 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
46893 }
46894 {
46895 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
46896 }
46897 {
46898 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
46899 }
46900 {
46901 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
46902 }
46903 {
46904 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
46905 }
46906 {
46907 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
46908 }
46909 {
46910 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
46911 }
46912 {
46913 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
46914 }
46915 {
46916 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
46917 }
46918 {
46919 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
46920 }
46921 {
46922 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
46923 }
46924 {
46925 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
46926 }
46927 {
46928 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
46929 }
46930 {
46931 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
46932 }
46933 {
46934 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
46935 }
46936 {
46937 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
46938 }
46939 {
46940 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
46941 }
46942 {
46943 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
46944 }
46945 {
46946 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
46947 }
46948 {
46949 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
46950 }
46951 {
46952 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
46953 }
46954 {
46955 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
46956 }
46957 {
46958 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
46959 }
46960 {
46961 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
46962 }
46963 {
46964 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
46965 }
46966 {
46967 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
46968 }
46969 {
46970 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
46971 }
46972 {
46973 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
46974 }
46975 {
46976 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
46977 }
46978 {
46979 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
46980 }
46981 {
46982 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
46983 }
46984 {
46985 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
46986 }
46987 {
46988 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
46989 }
46990 {
46991 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
46992 }
46993 {
46994 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
46995 }
46996 {
46997 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
46998 }
46999 {
47000 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
47001 }
47002 {
47003 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
47004 }
47005 {
47006 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
47007 }
47008 {
47009 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
47010 }
47011 {
47012 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
47013 }
47014 {
47015 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
47016 }
47017 {
47018 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
47019 }
47020 {
47021 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
47022 }
47023 {
47024 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
47025 }
47026 {
47027 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
47028 }
47029 {
47030 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
47031 }
47032 {
47033 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
47034 }
47035 {
47036 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
47037 }
47038 {
47039 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
47040 }
47041 {
47042 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
47043 }
47044 {
47045 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
47046 }
47047 {
47048 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
47049 }
47050 {
47051 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
47052 }
47053 {
47054 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
47055 }
47056 {
47057 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
47058 }
47059 {
47060 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
47061 }
47062 {
47063 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
47064 }
47065 {
47066 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
47067 }
47068 {
47069 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
47070 }
47071 {
47072 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
47073 }
47074 {
47075 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
47076 }
47077 {
47078 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
47079 }
47080 {
47081 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
47082 }
47083 {
47084 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
47085 }
47086 {
47087 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
47088 }
47089 {
47090 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
47091 }
47092 {
47093 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
47094 }
47095 {
47096 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
47097 }
47098 {
47099 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
47100 }
47101 {
47102 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
47103 }
47104 {
47105 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
47106 }
47107 {
47108 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
47109 }
47110 {
47111 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
47112 }
47113 {
47114 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
47115 }
47116 {
47117 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
47118 }
47119 {
47120 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
47121 }
47122 {
47123 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
47124 }
47125 {
47126 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
47127 }
47128 {
47129 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
47130 }
47131 {
47132 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
47133 }
47134 {
47135 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
47136 }
47137 {
47138 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
47139 }
47140 {
47141 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
47142 }
47143 {
47144 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
47145 }
47146 {
47147 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
47148 }
47149 {
47150 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
47151 }
47152 {
47153 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
47154 }
47155 {
47156 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
47157 }
47158 {
47159 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
47160 }
47161 {
47162 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
47163 }
47164 {
47165 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
47166 }
47167 {
47168 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
47169 }
47170 {
47171 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
47172 }
47173 {
47174 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
47175 }
47176 {
47177 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
47178 }
47179 {
47180 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
47181 }
47182 {
47183 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
47184 }
47185 {
47186 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
47187 }
47188 {
47189 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
47190 }
47191 {
47192 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
47193 }
47194 {
47195 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
47196 }
47197 {
47198 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
47199 }
47200 {
47201 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
47202 }
47203 {
47204 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
47205 }
47206 {
47207 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
47208 }
47209 {
47210 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
47211 }
47212 {
47213 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
47214 }
47215 {
47216 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
47217 }
47218 {
47219 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
47220 }
47221 {
47222 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
47223 }
47224 {
47225 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
47226 }
47227 {
47228 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
47229 }
47230 {
47231 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
47232 }
47233 {
47234 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
47235 }
47236 {
47237 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
47238 }
47239 {
47240 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
47241 }
47242 {
47243 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
47244 }
47245 {
47246 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
47247 }
47248 {
47249 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
47250 }
47251 {
47252 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
47253 }
47254 {
47255 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
47256 }
47257 {
47258 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
47259 }
47260 {
47261 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
47262 }
47263 {
47264 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
47265 }
47266 {
47267 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
47268 }
47269 {
47270 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
47271 }
47272 {
47273 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
47274 }
47275 {
47276 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
47277 }
47278 {
47279 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
47280 }
47281 {
47282 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
47283 }
47284 {
47285 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
47286 }
47287 {
47288 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
47289 }
47290 {
47291 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
47292 }
47293 {
47294 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
47295 }
47296 {
47297 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
47298 }
47299 {
47300 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
47301 }
47302 {
47303 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
47304 }
47305 {
47306 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
47307 }
47308 {
47309 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
47310 }
47311 {
47312 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
47313 }
47314 {
47315 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
47316 }
47317 {
47318 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
47319 }
47320 {
47321 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
47322 }
47323 {
47324 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
47325 }
47326 {
47327 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
47328 }
47329 {
47330 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
47331 }
47332 {
47333 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
47334 }
47335 {
47336 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
47337 }
47338 {
47339 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
47340 }
47341 {
47342 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
47343 }
47344 {
47345 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
47346 }
47347 {
47348 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
47349 }
47350 {
47351 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
47352 }
47353 {
47354 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
47355 }
47356 {
47357 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
47358 }
47359 {
47360 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
47361 }
47362 {
47363 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
47364 }
47365 {
47366 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
47367 }
47368 {
47369 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
47370 }
47371 {
47372 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
47373 }
47374 {
47375 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
47376 }
47377 {
47378 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
47379 }
47380 {
47381 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
47382 }
47383 {
47384 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
47385 }
47386 {
47387 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
47388 }
47389 {
47390 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
47391 }
47392 {
47393 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
47394 }
47395 {
47396 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
47397 }
47398 {
47399 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
47400 }
47401 {
47402 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
47403 }
47404 {
47405 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
47406 }
47407 {
47408 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
47409 }
47410 {
47411 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
47412 }
47413 {
47414 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
47415 }
47416 {
47417 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
47418 }
47419 {
47420 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
47421 }
47422 {
47423 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
47424 }
47425 {
47426 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
47427 }
47428 {
47429 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
47430 }
47431 {
47432 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
47433 }
47434 {
47435 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
47436 }
47437 {
47438 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
47439 }
47440 {
47441 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
47442 }
47443 {
47444 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
47445 }
47446 {
47447 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
47448 }
47449 {
47450 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
47451 }
47452 {
47453 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
47454 }
47455 {
47456 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
47457 }
47458 {
47459 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
47460 }
47461 {
47462 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
47463 }
47464 {
47465 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
47466 }
47467 {
47468 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
47469 }
47470 {
47471 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
47472 }
47473 {
47474 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
47475 }
47476 {
47477 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
47478 }
47479 {
47480 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
47481 }
47482 {
47483 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
47484 }
47485 {
47486 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
47487 }
47488 {
47489 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
47490 }
47491 {
47492 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
47493 }
47494 {
47495 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
47496 }
47497 {
47498 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
47499 }
47500 {
47501 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
47502 }
47503 {
47504 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
47505 }
47506 {
47507 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
47508 }
47509 {
47510 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
47511 }
47512 {
47513 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
47514 }
47515 {
47516 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
47517 }
47518 {
47519 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
47520 }
47521 {
47522 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
47523 }
47524 {
47525 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
47526 }
47527 {
47528 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
47529 }
47530 {
47531 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
47532 }
47533 {
47534 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
47535 }
47536 {
47537 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
47538 }
47539 {
47540 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
47541 }
47542 {
47543 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
47544 }
47545 {
47546 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
47547 }
47548 {
47549 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
47550 }
47551 {
47552 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
47553 }
47554 {
47555 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
47556 }
47557 {
47558 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
47559 }
47560 {
47561 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
47562 }
47563 {
47564 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
47565 }
47566 {
47567 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
47568 }
47569 {
47570 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
47571 }
47572 {
47573 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
47574 }
47575 {
47576 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
47577 }
47578 {
47579 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
47580 }
47581 {
47582 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
47583 }
47584 {
47585 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
47586 }
47587 {
47588 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
47589 }
47590 {
47591 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
47592 }
47593 {
47594 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
47595 }
47596 {
47597 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
47598 }
47599 {
47600 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
47601 }
47602 {
47603 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
47604 }
47605 {
47606 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
47607 }
47608 {
47609 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
47610 }
47611 {
47612 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
47613 }
47614 {
47615 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
47616 }
47617 {
47618 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
47619 }
47620 {
47621 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
47622 }
47623 {
47624 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
47625 }
47626 {
47627 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
47628 }
47629 {
47630 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
47631 }
47632 {
47633 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
47634 }
47635 {
47636 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
47637 }
47638 {
47639 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
47640 }
47641 {
47642 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
47643 }
47644 {
47645 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
47646 }
47647 {
47648 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
47649 }
47650 {
47651 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
47652 }
47653 {
47654 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
47655 }
47656 {
47657 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
47658 }
47659 {
47660 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
47661 }
47662 {
47663 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
47664 }
47665 {
47666 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
47667 }
47668 {
47669 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
47670 }
47671 {
47672 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
47673 }
47674 {
47675 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
47676 }
47677 {
47678 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
47679 }
47680 {
47681 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
47682 }
47683 {
47684 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
47685 }
47686 {
47687 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
47688 }
47689 {
47690 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
47691 }
47692 {
47693 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
47694 }
47695 {
47696 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
47697 }
47698 {
47699 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
47700 }
47701 {
47702 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
47703 }
47704 {
47705 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
47706 }
47707 {
47708 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
47709 }
47710 {
47711 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
47712 }
47713 {
47714 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
47715 }
47716 {
47717 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
47718 }
47719 {
47720 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
47721 }
47722 {
47723 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
47724 }
47725 {
47726 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
47727 }
47728 {
47729 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
47730 }
47731 {
47732 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
47733 }
47734 {
47735 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
47736 }
47737 {
47738 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
47739 }
47740 {
47741 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
47742 }
47743 {
47744 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
47745 }
47746 {
47747 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
47748 }
47749 {
47750 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
47751 }
47752 {
47753 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
47754 }
47755 {
47756 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
47757 }
47758 {
47759 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
47760 }
47761 {
47762 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
47763 }
47764 {
47765 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
47766 }
47767 {
47768 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
47769 }
47770 {
47771 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
47772 }
47773 {
47774 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
47775 }
47776 {
47777 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
47778 }
47779 {
47780 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
47781 }
47782 {
47783 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
47784 }
47785 {
47786 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
47787 }
47788 {
47789 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
47790 }
47791 {
47792 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
47793 }
47794 {
47795 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
47796 }
47797 {
47798 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
47799 }
47800 {
47801 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
47802 }
47803 {
47804 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
47805 }
47806 {
47807 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
47808 }
47809 {
47810 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
47811 }
47812 {
47813 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
47814 }
47815 {
47816 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
47817 }
47818 {
47819 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
47820 }
47821 {
47822 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
47823 }
47824 {
47825 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
47826 }
47827 {
47828 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
47829 }
47830 {
47831 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
47832 }
47833 {
47834 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
47835 }
47836 {
47837 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
47838 }
47839 {
47840 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
47841 }
47842 {
47843 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
47844 }
47845 {
47846 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
47847 }
47848 {
47849 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
47850 }
47851 {
47852 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
47853 }
47854 {
47855 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
47856 }
47857 {
47858 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
47859 }
47860 {
47861 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
47862 }
47863 {
47864 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
47865 }
47866 {
47867 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
47868 }
47869 {
47870 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
47871 }
47872 {
47873 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
47874 }
47875 {
47876 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
47877 }
47878 {
47879 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
47880 }
47881 {
47882 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
47883 }
47884 {
47885 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
47886 }
47887 {
47888 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
47889 }
47890 {
47891 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
47892 }
47893 {
47894 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
47895 }
47896 {
47897 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
47898 }
47899 {
47900 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
47901 }
47902 {
47903 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
47904 }
47905 {
47906 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
47907 }
47908 {
47909 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
47910 }
47911 {
47912 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
47913 }
47914 {
47915 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
47916 }
47917 {
47918 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
47919 }
47920 {
47921 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
47922 }
47923 {
47924 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
47925 }
47926 {
47927 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
47928 }
47929 {
47930 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
47931 }
47932 {
47933 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
47934 }
47935 {
47936 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
47937 }
47938 {
47939 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
47940 }
47941 {
47942 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
47943 }
47944 {
47945 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
47946 }
47947 {
47948 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
47949 }
47950 {
47951 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
47952 }
47953 {
47954 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
47955 }
47956 {
47957 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
47958 }
47959 {
47960 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
47961 }
47962 {
47963 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
47964 }
47965 {
47966 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
47967 }
47968 {
47969 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
47970 }
47971 {
47972 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
47973 }
47974 {
47975 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
47976 }
47977 {
47978 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
47979 }
47980 {
47981 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
47982 }
47983 {
47984 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
47985 }
47986 {
47987 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
47988 }
47989 {
47990 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
47991 }
47992 {
47993 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
47994 }
47995 {
47996 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
47997 }
47998 {
47999 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
48000 }
48001 {
48002 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
48003 }
48004 {
48005 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
48006 }
48007 {
48008 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
48009 }
48010 {
48011 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
48012 }
48013 {
48014 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
48015 }
48016 {
48017 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
48018 }
48019 {
48020 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
48021 }
48022 {
48023 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
48024 }
48025 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
48026 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
48027 {
48028 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
48029 }
48030 {
48031 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
48032 }
48033 {
48034 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
48035 }
48036 {
48037 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
48038 }
48039 {
48040 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
48041 }
48042 {
48043 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
48044 }
48045 {
48046 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
48047 }
48048 {
48049 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
48050 }
48051 {
48052 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
48053 }
48054 {
48055 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
48056 }
48057 {
48058 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
48059 }
48060 {
48061 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
48062 }
48063 {
48064 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
48065 }
48066 {
48067 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
48068 }
48069 {
48070 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
48071 }
48072 {
48073 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
48074 }
48075 {
48076 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
48077 }
48078 {
48079 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
48080 }
48081 {
48082 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
48083 }
48084 {
48085 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
48086 }
48087 {
48088 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
48089 }
48090 {
48091 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
48092 }
48093 {
48094 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
48095 }
48096 {
48097 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
48098 }
48099 {
48100 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
48101 }
48102 {
48103 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
48104 }
48105 {
48106 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
48107 }
48108 {
48109 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
48110 }
48111 {
48112 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
48113 }
48114 {
48115 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
48116 }
48117 {
48118 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
48119 }
48120 {
48121 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
48122 }
48123 {
48124 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
48125 }
48126 {
48127 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
48128 }
48129 {
48130 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
48131 }
48132 {
48133 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
48134 }
48135 {
48136 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
48137 }
48138 {
48139 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
48140 }
48141 {
48142 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
48143 }
48144 {
48145 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
48146 }
48147 {
48148 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
48149 }
48150 {
48151 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
48152 }
48153 {
48154 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
48155 }
48156 {
48157 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
48158 }
48159 {
48160 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
48161 }
48162 {
48163 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
48164 }
48165 {
48166 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
48167 }
48168 {
48169 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
48170 }
48171 {
48172 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
48173 }
48174 {
48175 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
48176 }
48177 {
48178 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
48179 }
48180 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
48181 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
48182 {
48183 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
48184 }
48185 {
48186 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
48187 }
48188 {
48189 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
48190 }
48191
48192 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
48193
48194
48195 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
48196
48197 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
48198 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
48199 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
48200 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
48201 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
48202 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
48203 {
48204 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
48205 }
48206 {
48207 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
48208 }
48209 {
48210 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
48211 }
48212 {
48213 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
48214 }
48215 {
48216 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
48217 }
48218 {
48219 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
48220 }
48221 {
48222 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
48223 }
48224 {
48225 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
48226 }
48227 {
48228 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
48229 }
48230 {
48231 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
48232 }
48233 {
48234 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
48235 }
48236 {
48237 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
48238 }
48239 {
48240 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
48241 }
48242 {
48243 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
48244 }
48245 {
48246 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
48247 }
48248 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
48249 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
48250 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
48251 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
48252 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
48253 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
48254 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
48255 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
48256 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
48257 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
48258 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
48259 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
48260 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
48261 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
48262 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
48263 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
48264 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
48265 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
48266 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
48267 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
48268 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
48269 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
48270 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
48271 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
48272 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
48273 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
48274 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
48275 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
48276 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
48277 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
48278 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
48279 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
48280 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
48281 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
48282 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
48283 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
48284 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
48285 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
48286 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
48287 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
48288 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
48289 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
48290 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
48291 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
48292 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
48293 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
48294 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
48295 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
48296 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
48297 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
48298 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
48299 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
48300 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
48301 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
48302 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
48303 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
48304 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
48305 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
48306 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
48307 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
48308 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
48309 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
48310 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
48311 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
48312 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
48313 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
48314 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
48315 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
48316 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
48317 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
48318 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
48319 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
48320 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
48321 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
48322 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
48323 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
48324 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
48325 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
48326 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
48327 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
48328 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
48329 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
48330 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
48331 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
48332 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
48333 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
48334 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
48335 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
48336 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
48337 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
48338 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
48339 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
48340 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
48341 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
48342 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
48343 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
48344 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
48345 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
48346 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
48347 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
48348 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
48349 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
48350 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
48351 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
48352 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
48353 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
48354 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
48355 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
48356 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
48357 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
48358 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
48359 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
48360 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
48361 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
48362 {
48363 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
48364 }
48365 {
48366 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
48367 }
48368 {
48369 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
48370 }
48371 {
48372 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
48373 }
48374 {
48375 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
48376 }
48377 {
48378 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
48379 }
48380 {
48381 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
48382 }
48383 {
48384 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
48385 }
48386 {
48387 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
48388 }
48389 {
48390 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
48391 }
48392 {
48393 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
48394 }
48395 {
48396 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
48397 }
48398 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
48399 {
48400 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
48401 }
48402 {
48403 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
48404 }
48405 {
48406 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
48407 }
48408 {
48409 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
48410 }
48411 {
48412 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
48413 }
48414 {
48415 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
48416 }
48417 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
48418 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
48419 {
48420 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
48421 }
48422 {
48423 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
48424 }
48425 {
48426 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
48427 }
48428 {
48429 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
48430 }
48431 {
48432 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
48433 }
48434 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
48435 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
48436 {
48437 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
48438 }
48439 {
48440 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
48441 }
48442 {
48443 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
48444 }
48445 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
48446 {
48447 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
48448 }
48449 {
48450 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
48451 }
48452 {
48453 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
48454 }
48455 {
48456 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
48457 }
48458 {
48459 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
48460 }
48461 {
48462 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
48463 }
48464 {
48465 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
48466 }
48467 {
48468 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
48469 }
48470 {
48471 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
48472 }
48473 {
48474 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
48475 }
48476 {
48477 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
48478 }
48479 {
48480 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
48481 }
48482 {
48483 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
48484 }
48485 {
48486 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
48487 }
48488 {
48489 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
48490 }
48491 {
48492 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
48493 }
48494 {
48495 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
48496 }
48497 {
48498 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
48499 }
48500 {
48501 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
48502 }
48503
48504 // Initialize threading, some globals and such
48505 __wxPyPreStart(d);
48506
48507
48508 // Although these are defined in __version__ they need to be here too so
48509 // that an assert can be done to ensure that the wxPython and the wxWindows
48510 // versions match.
48511 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
48512 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
48513 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
48514
48515 }
48516
wxWidgets (Impactor)