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


27edb0ff9df82fb7766a5b7e98003eb9fb2b96d0
[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_FILENAME(wxIMAGE_OPTION_FILENAME);
2467 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2468 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2469 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2470 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2471 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2472 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2473 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2474 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2475 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2476 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2477 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2478
2479 #include <wx/quantize.h>
2480
2481 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2482 return wxQuantize::Quantize(src, dest,
2483 //NULL, // palette
2484 desiredNoColours,
2485 NULL, // eightBitData
2486 flags);
2487 }
2488 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2489 if (PyCallable_Check(func)) {
2490 self->Connect(id, lastId, eventType,
2491 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2492 new wxPyCallback(func));
2493 }
2494 else if (func == Py_None) {
2495 self->Disconnect(id, lastId, eventType,
2496 (wxObjectEventFunction)
2497 &wxPyCallback::EventThunker);
2498 }
2499 else {
2500 wxPyBLOCK_THREADS(
2501 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2502 }
2503 }
2504 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2505 return self->Disconnect(id, lastId, eventType,
2506 (wxObjectEventFunction)
2507 &wxPyCallback::EventThunker);
2508 }
2509 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2510 if (_self && _self != Py_None) {
2511 self->SetClientObject(new wxPyOORClientData(_self, incref));
2512 }
2513 else {
2514 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2515 if (data) {
2516 self->SetClientObject(NULL); // This will delete it too
2517 }
2518 }
2519 }
2520
2521 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2522 #if wxUSE_UNICODE
2523 return self->GetUnicodeKey();
2524 #else
2525 return 0;
2526 #endif
2527 }
2528
2529 #if UINT_MAX < LONG_MAX
2530 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2531 #define SWIG_From_unsigned_SS_int SWIG_From_long
2532 /*@@*/
2533 #else
2534 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2535 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2536 /*@@*/
2537 #endif
2538
2539
2540 #if UINT_MAX != ULONG_MAX
2541 SWIGINTERN int
2542 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2543 {
2544 const char* errmsg = val ? "unsigned int" : (char*)0;
2545 unsigned long v;
2546 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2547 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2548 if (val) *val = (unsigned int)(v);
2549 return 1;
2550 }
2551 } else {
2552 PyErr_Clear();
2553 }
2554 if (val) {
2555 SWIG_type_error(errmsg, obj);
2556 }
2557 return 0;
2558 }
2559 #else
2560 SWIGINTERNSHORT unsigned int
2561 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2562 {
2563 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2564 }
2565 #endif
2566
2567
2568 SWIGINTERNSHORT unsigned int
2569 SWIG_As_unsigned_SS_int(PyObject* obj)
2570 {
2571 unsigned int v;
2572 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2573 /*
2574 this is needed to make valgrind/purify happier.
2575 */
2576 memset((void*)&v, 0, sizeof(unsigned int));
2577 }
2578 return v;
2579 }
2580
2581
2582 SWIGINTERNSHORT int
2583 SWIG_Check_unsigned_SS_int(PyObject* obj)
2584 {
2585 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2586 }
2587
2588 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2589 self->m_size = size;
2590 }
2591 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2592 int count = self->GetNumberOfFiles();
2593 wxString* files = self->GetFiles();
2594 PyObject* list = PyList_New(count);
2595
2596 if (!list) {
2597 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2598 return NULL;
2599 }
2600
2601 for (int i=0; i<count; i++) {
2602 PyList_SetItem(list, i, wx2PyString(files[i]));
2603 }
2604 return list;
2605 }
2606
2607
2608 static wxPyApp *new_wxPyApp(){
2609 wxPythonApp = new wxPyApp();
2610 return wxPythonApp;
2611 }
2612 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2613
2614 void wxApp_CleanUp() {
2615 __wxPyCleanup();
2616 }
2617
2618
2619 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2620
2621
2622 SWIGINTERNSHORT int
2623 SWIG_AsCharPtr(PyObject *obj, char **val)
2624 {
2625 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2626 return 1;
2627 }
2628 if (val) {
2629 PyErr_Clear();
2630 SWIG_type_error("char *", obj);
2631 }
2632 return 0;
2633 }
2634
2635
2636 SWIGINTERN PyObject *
2637 SWIG_FromCharPtr(const char* cptr)
2638 {
2639 if (cptr) {
2640 size_t size = strlen(cptr);
2641 if (size > INT_MAX) {
2642 return SWIG_NewPointerObj((char*)(cptr),
2643 SWIG_TypeQuery("char *"), 0);
2644 } else {
2645 if (size != 0) {
2646 return PyString_FromStringAndSize(cptr, size);
2647 } else {
2648 return PyString_FromString(cptr);
2649 }
2650 }
2651 }
2652 Py_INCREF(Py_None);
2653 return Py_None;
2654 }
2655
2656
2657 #ifdef __WXMAC__
2658
2659 // A dummy class that raises an exception if used...
2660 class wxEventLoop
2661 {
2662 public:
2663 wxEventLoop() { wxPyRaiseNotImplemented(); }
2664 int Run() { return 0; }
2665 void Exit(int rc = 0) {}
2666 bool Pending() const { return false; }
2667 bool Dispatch() { return false; }
2668 bool IsRunning() const { return false; }
2669 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2670 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2671 };
2672
2673 #else
2674
2675 #include <wx/evtloop.h>
2676
2677 #endif
2678
2679
2680
2681 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2682 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2683 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2684 static PyObject *wxWindow_GetChildren(wxWindow *self){
2685 wxWindowList& list = self->GetChildren();
2686 return wxPy_ConvertList(&list);
2687 }
2688 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2689 #if wxUSE_HOTKEY
2690 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2691 #else
2692 return false;
2693 #endif
2694 }
2695 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2696
2697
2698
2699 return false;
2700
2701 }
2702 static long wxWindow_GetHandle(wxWindow *self){
2703 return wxPyGetWinHandle(self);
2704 }
2705 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2706 self->AssociateHandle((WXWidget)handle);
2707 }
2708
2709 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2710 return wxWindow::FindWindowById(id, parent);
2711 }
2712
2713 wxWindow* wxFindWindowByName( const wxString& name,
2714 const wxWindow *parent = NULL ) {
2715 return wxWindow::FindWindowByName(name, parent);
2716 }
2717
2718 wxWindow* wxFindWindowByLabel( const wxString& label,
2719 const wxWindow *parent = NULL ) {
2720 return wxWindow::FindWindowByLabel(label, parent);
2721 }
2722
2723
2724 #ifdef __WXMSW__
2725 #include <wx/msw/private.h> // to get wxGetWindowId
2726 #endif
2727
2728
2729 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2730 #ifdef __WXMSW__
2731 WXHWND hWnd = (WXHWND)_hWnd;
2732 long id = wxGetWindowId(hWnd);
2733 wxWindow* win = new wxWindow;
2734 parent->AddChild(win);
2735 win->SetEventHandler(win);
2736 win->SetHWND(hWnd);
2737 win->SetId(id);
2738 win->SubclassWin(hWnd);
2739 win->AdoptAttributesFromHWND();
2740 win->SetupColours();
2741 return win;
2742 #else
2743 wxPyRaiseNotImplemented();
2744 return NULL;
2745 #endif
2746 }
2747
2748
2749 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2750 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2751 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2752
2753 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2754
2755 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2756 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2757 wxMenuItemList& list = self->GetMenuItems();
2758 return wxPy_ConvertList(&list);
2759 }
2760 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2761 static const wxString wxPyControlNameStr(wxControlNameStr);
2762 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2763 if (clientData) {
2764 wxPyClientData* data = new wxPyClientData(clientData);
2765 return self->Append(item, data);
2766 } else
2767 return self->Append(item);
2768 }
2769 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2770 if (clientData) {
2771 wxPyClientData* data = new wxPyClientData(clientData);
2772 return self->Insert(item, pos, data);
2773 } else
2774 return self->Insert(item, pos);
2775 }
2776 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2777 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2778 if (data) {
2779 Py_INCREF(data->m_obj);
2780 return data->m_obj;
2781 } else {
2782 Py_INCREF(Py_None);
2783 return Py_None;
2784 }
2785 }
2786 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2787 wxPyClientData* data = new wxPyClientData(clientData);
2788 self->SetClientObject(n, data);
2789 }
2790
2791
2792 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2793 wxPyUserData* data = NULL;
2794 if ( userData ) {
2795 bool blocked = wxPyBeginBlockThreads();
2796 data = new wxPyUserData(userData);
2797 wxPyEndBlockThreads(blocked);
2798 }
2799 return new wxSizerItem(window, proportion, flag, border, data);
2800 }
2801 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2802 wxPyUserData* data = NULL;
2803 if ( userData ) {
2804 bool blocked = wxPyBeginBlockThreads();
2805 data = new wxPyUserData(userData);
2806 wxPyEndBlockThreads(blocked);
2807 }
2808 return new wxSizerItem(width, height, proportion, flag, border, data);
2809 }
2810 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2811 wxPyUserData* data = NULL;
2812 if ( userData ) {
2813 bool blocked = wxPyBeginBlockThreads();
2814 data = new wxPyUserData(userData);
2815 wxPyEndBlockThreads(blocked);
2816 }
2817 return new wxSizerItem(sizer, proportion, flag, border, data);
2818 }
2819
2820 #include <float.h>
2821 SWIGINTERN int
2822 SWIG_CheckDoubleInRange(double value, double min_value,
2823 double max_value, const char* errmsg)
2824 {
2825 if (value < min_value) {
2826 if (errmsg) {
2827 PyErr_Format(PyExc_OverflowError,
2828 "value %g is less than %s minimum %g",
2829 value, errmsg, min_value);
2830 }
2831 return 0;
2832 } else if (value > max_value) {
2833 if (errmsg) {
2834 PyErr_Format(PyExc_OverflowError,
2835 "value %g is greater than %s maximum %g",
2836 value, errmsg, max_value);
2837 }
2838 return 0;
2839 }
2840 return 1;
2841 }
2842
2843
2844 SWIGINTERN int
2845 SWIG_AsVal_float(PyObject *obj, float *val)
2846 {
2847 const char* errmsg = val ? "float" : (char*)0;
2848 double v;
2849 if (SWIG_AsVal_double(obj, &v)) {
2850 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2851 if (val) *val = (float)(v);
2852 return 1;
2853 } else {
2854 return 0;
2855 }
2856 } else {
2857 PyErr_Clear();
2858 }
2859 if (val) {
2860 SWIG_type_error(errmsg, obj);
2861 }
2862 return 0;
2863 }
2864
2865
2866 SWIGINTERNSHORT float
2867 SWIG_As_float(PyObject* obj)
2868 {
2869 float v;
2870 if (!SWIG_AsVal_float(obj, &v)) {
2871 /*
2872 this is needed to make valgrind/purify happier.
2873 */
2874 memset((void*)&v, 0, sizeof(float));
2875 }
2876 return v;
2877 }
2878
2879
2880 SWIGINTERNSHORT int
2881 SWIG_Check_float(PyObject* obj)
2882 {
2883 return SWIG_AsVal_float(obj, (float*)0);
2884 }
2885
2886
2887 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2888 #define SWIG_From_float PyFloat_FromDouble
2889 /*@@*/
2890
2891 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2892 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2893 if (data) {
2894 Py_INCREF(data->m_obj);
2895 return data->m_obj;
2896 } else {
2897 Py_INCREF(Py_None);
2898 return Py_None;
2899 }
2900 }
2901
2902 // Figure out the type of the sizer item
2903
2904 struct wxPySizerItemInfo {
2905 wxPySizerItemInfo()
2906 : window(NULL), sizer(NULL), gotSize(false),
2907 size(wxDefaultSize), gotPos(false), pos(-1)
2908 {}
2909
2910 wxWindow* window;
2911 wxSizer* sizer;
2912 bool gotSize;
2913 wxSize size;
2914 bool gotPos;
2915 int pos;
2916 };
2917
2918 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2919
2920 wxPySizerItemInfo info;
2921 wxSize size;
2922 wxSize* sizePtr = &size;
2923
2924 // Find out what the type of the item is
2925 // try wxWindow
2926 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2927 PyErr_Clear();
2928 info.window = NULL;
2929
2930 // try wxSizer
2931 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2932 PyErr_Clear();
2933 info.sizer = NULL;
2934
2935 // try wxSize or (w,h)
2936 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2937 info.size = *sizePtr;
2938 info.gotSize = true;
2939 }
2940
2941 // or a single int
2942 if (checkIdx && PyInt_Check(item)) {
2943 info.pos = PyInt_AsLong(item);
2944 info.gotPos = true;
2945 }
2946 }
2947 }
2948
2949 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2950 // no expected type, figure out what kind of error message to generate
2951 if ( !checkSize && !checkIdx )
2952 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2953 else if ( checkSize && !checkIdx )
2954 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2955 else if ( !checkSize && checkIdx)
2956 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2957 else
2958 // can this one happen?
2959 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2960 }
2961
2962 return info;
2963 }
2964
2965 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2966 if (!self->GetClientObject())
2967 self->SetClientObject(new wxPyOORClientData(_self));
2968 }
2969 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2970
2971 wxPyUserData* data = NULL;
2972 bool blocked = wxPyBeginBlockThreads();
2973 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2974 if ( userData && (info.window || info.sizer || info.gotSize) )
2975 data = new wxPyUserData(userData);
2976 wxPyEndBlockThreads(blocked);
2977
2978 // Now call the real Add method if a valid item type was found
2979 if ( info.window )
2980 return self->Add(info.window, proportion, flag, border, data);
2981 else if ( info.sizer )
2982 return self->Add(info.sizer, proportion, flag, border, data);
2983 else if (info.gotSize)
2984 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
2985 proportion, flag, border, data);
2986 else
2987 return NULL;
2988 }
2989 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2990
2991 wxPyUserData* data = NULL;
2992 bool blocked = wxPyBeginBlockThreads();
2993 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2994 if ( userData && (info.window || info.sizer || info.gotSize) )
2995 data = new wxPyUserData(userData);
2996 wxPyEndBlockThreads(blocked);
2997
2998 // Now call the real Insert method if a valid item type was found
2999 if ( info.window )
3000 return self->Insert(before, info.window, proportion, flag, border, data);
3001 else if ( info.sizer )
3002 return self->Insert(before, info.sizer, proportion, flag, border, data);
3003 else if (info.gotSize)
3004 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3005 proportion, flag, border, data);
3006 else
3007 return NULL;
3008 }
3009 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3010
3011 wxPyUserData* data = NULL;
3012 bool blocked = wxPyBeginBlockThreads();
3013 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3014 if ( userData && (info.window || info.sizer || info.gotSize) )
3015 data = new wxPyUserData(userData);
3016 wxPyEndBlockThreads(blocked);
3017
3018 // Now call the real Prepend method if a valid item type was found
3019 if ( info.window )
3020 return self->Prepend(info.window, proportion, flag, border, data);
3021 else if ( info.sizer )
3022 return self->Prepend(info.sizer, proportion, flag, border, data);
3023 else if (info.gotSize)
3024 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3025 proportion, flag, border, data);
3026 else
3027 return NULL;
3028 }
3029 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3030 bool blocked = wxPyBeginBlockThreads();
3031 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3032 wxPyEndBlockThreads(blocked);
3033 if ( info.window )
3034 return self->Remove(info.window);
3035 else if ( info.sizer )
3036 return self->Remove(info.sizer);
3037 else if ( info.gotPos )
3038 return self->Remove(info.pos);
3039 else
3040 return false;
3041 }
3042 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3043 bool blocked = wxPyBeginBlockThreads();
3044 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3045 wxPyEndBlockThreads(blocked);
3046 if ( info.window )
3047 return self->Detach(info.window);
3048 else if ( info.sizer )
3049 return self->Detach(info.sizer);
3050 else if ( info.gotPos )
3051 return self->Detach(info.pos);
3052 else
3053 return false;
3054 }
3055 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3056 bool blocked = wxPyBeginBlockThreads();
3057 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3058 wxPyEndBlockThreads(blocked);
3059 if ( info.window )
3060 return self->GetItem(info.window);
3061 else if ( info.sizer )
3062 return self->GetItem(info.sizer);
3063 else if ( info.gotPos )
3064 return self->GetItem(info.pos);
3065 else
3066 return NULL;
3067 }
3068 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3069 bool blocked = wxPyBeginBlockThreads();
3070 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3071 wxPyEndBlockThreads(blocked);
3072 if ( info.window )
3073 self->SetItemMinSize(info.window, size);
3074 else if ( info.sizer )
3075 self->SetItemMinSize(info.sizer, size);
3076 else if ( info.gotPos )
3077 self->SetItemMinSize(info.pos, size);
3078 }
3079 static PyObject *wxSizer_GetChildren(wxSizer *self){
3080 wxSizerItemList& list = self->GetChildren();
3081 return wxPy_ConvertList(&list);
3082 }
3083 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3084 bool blocked = wxPyBeginBlockThreads();
3085 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3086 wxPyEndBlockThreads(blocked);
3087 if ( info.window )
3088 return self->Show(info.window, show, recursive);
3089 else if ( info.sizer )
3090 return self->Show(info.sizer, show, recursive);
3091 else if ( info.gotPos )
3092 return self->Show(info.pos, show);
3093 else
3094 return false;
3095 }
3096 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3097 bool blocked = wxPyBeginBlockThreads();
3098 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3099 wxPyEndBlockThreads(blocked);
3100 if ( info.window )
3101 return self->IsShown(info.window);
3102 else if ( info.sizer )
3103 return self->IsShown(info.sizer);
3104 else if ( info.gotPos )
3105 return self->IsShown(info.pos);
3106 else
3107 return false;
3108 }
3109
3110 // See pyclasses.h
3111 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3112 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3113 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3114
3115
3116
3117
3118 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3119 {
3120 if (source == Py_None) {
3121 **obj = wxGBPosition(-1,-1);
3122 return true;
3123 }
3124 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3125 }
3126
3127 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3128 {
3129 if (source == Py_None) {
3130 **obj = wxGBSpan(-1,-1);
3131 return true;
3132 }
3133 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3134 }
3135
3136
3137 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3138 self->SetRow(row);
3139 self->SetCol(col);
3140 }
3141 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3142 bool blocked = wxPyBeginBlockThreads();
3143 PyObject* tup = PyTuple_New(2);
3144 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3145 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3146 wxPyEndBlockThreads(blocked);
3147 return tup;
3148 }
3149 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3150 self->SetRowspan(rowspan);
3151 self->SetColspan(colspan);
3152 }
3153 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3154 bool blocked = wxPyBeginBlockThreads();
3155 PyObject* tup = PyTuple_New(2);
3156 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3157 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3158 wxPyEndBlockThreads(blocked);
3159 return tup;
3160 }
3161 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3162 wxPyUserData* data = NULL;
3163 if ( userData ) {
3164 bool blocked = wxPyBeginBlockThreads();
3165 data = new wxPyUserData(userData);
3166 wxPyEndBlockThreads(blocked);
3167 }
3168 return new wxGBSizerItem(window, pos, span, flag, border, data);
3169 }
3170 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3171 wxPyUserData* data = NULL;
3172 if ( userData ) {
3173 bool blocked = wxPyBeginBlockThreads();
3174 data = new wxPyUserData(userData);
3175 wxPyEndBlockThreads(blocked);
3176 }
3177 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3178 }
3179 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3180 wxPyUserData* data = NULL;
3181 if ( userData ) {
3182 bool blocked = wxPyBeginBlockThreads();
3183 data = new wxPyUserData(userData);
3184 wxPyEndBlockThreads(blocked);
3185 }
3186 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3187 }
3188 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3189 int row, col;
3190 self->GetEndPos(row, col);
3191 return wxGBPosition(row, col);
3192 }
3193 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3194
3195 wxPyUserData* data = NULL;
3196 bool blocked = wxPyBeginBlockThreads();
3197 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3198 if ( userData && (info.window || info.sizer || info.gotSize) )
3199 data = new wxPyUserData(userData);
3200 wxPyEndBlockThreads(blocked);
3201
3202 // Now call the real Add method if a valid item type was found
3203 if ( info.window )
3204 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3205 else if ( info.sizer )
3206 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3207 else if (info.gotSize)
3208 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3209 pos, span, flag, border, data);
3210 return NULL;
3211 }
3212
3213
3214 #ifdef __cplusplus
3215 extern "C" {
3216 #endif
3217 static int _wrap_EmptyString_set(PyObject *) {
3218 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3219 return 1;
3220 }
3221
3222
3223 static PyObject *_wrap_EmptyString_get(void) {
3224 PyObject *pyobj;
3225
3226 {
3227 #if wxUSE_UNICODE
3228 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3229 #else
3230 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3231 #endif
3232 }
3233 return pyobj;
3234 }
3235
3236
3237 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3238 PyObject *resultobj;
3239 wxObject *arg1 = (wxObject *) 0 ;
3240 wxString result;
3241 PyObject * obj0 = 0 ;
3242 char *kwnames[] = {
3243 (char *) "self", NULL
3244 };
3245
3246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3248 if (SWIG_arg_fail(1)) SWIG_fail;
3249 {
3250 PyThreadState* __tstate = wxPyBeginAllowThreads();
3251 result = wxObject_GetClassName(arg1);
3252
3253 wxPyEndAllowThreads(__tstate);
3254 if (PyErr_Occurred()) SWIG_fail;
3255 }
3256 {
3257 #if wxUSE_UNICODE
3258 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3259 #else
3260 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3261 #endif
3262 }
3263 return resultobj;
3264 fail:
3265 return NULL;
3266 }
3267
3268
3269 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3270 PyObject *resultobj;
3271 wxObject *arg1 = (wxObject *) 0 ;
3272 PyObject * obj0 = 0 ;
3273 char *kwnames[] = {
3274 (char *) "self", NULL
3275 };
3276
3277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3279 if (SWIG_arg_fail(1)) SWIG_fail;
3280 {
3281 PyThreadState* __tstate = wxPyBeginAllowThreads();
3282 wxObject_Destroy(arg1);
3283
3284 wxPyEndAllowThreads(__tstate);
3285 if (PyErr_Occurred()) SWIG_fail;
3286 }
3287 Py_INCREF(Py_None); resultobj = Py_None;
3288 return resultobj;
3289 fail:
3290 return NULL;
3291 }
3292
3293
3294 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3295 PyObject *obj;
3296 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3297 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3298 Py_INCREF(obj);
3299 return Py_BuildValue((char *)"");
3300 }
3301 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3302 PyObject *resultobj;
3303 wxSize *arg1 = (wxSize *) 0 ;
3304 int arg2 ;
3305 PyObject * obj0 = 0 ;
3306 PyObject * obj1 = 0 ;
3307 char *kwnames[] = {
3308 (char *) "self",(char *) "x", NULL
3309 };
3310
3311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3313 if (SWIG_arg_fail(1)) SWIG_fail;
3314 {
3315 arg2 = (int)(SWIG_As_int(obj1));
3316 if (SWIG_arg_fail(2)) SWIG_fail;
3317 }
3318 if (arg1) (arg1)->x = arg2;
3319
3320 Py_INCREF(Py_None); resultobj = Py_None;
3321 return resultobj;
3322 fail:
3323 return NULL;
3324 }
3325
3326
3327 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3328 PyObject *resultobj;
3329 wxSize *arg1 = (wxSize *) 0 ;
3330 int result;
3331 PyObject * obj0 = 0 ;
3332 char *kwnames[] = {
3333 (char *) "self", NULL
3334 };
3335
3336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3338 if (SWIG_arg_fail(1)) SWIG_fail;
3339 result = (int) ((arg1)->x);
3340
3341 {
3342 resultobj = SWIG_From_int((int)(result));
3343 }
3344 return resultobj;
3345 fail:
3346 return NULL;
3347 }
3348
3349
3350 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3351 PyObject *resultobj;
3352 wxSize *arg1 = (wxSize *) 0 ;
3353 int arg2 ;
3354 PyObject * obj0 = 0 ;
3355 PyObject * obj1 = 0 ;
3356 char *kwnames[] = {
3357 (char *) "self",(char *) "y", NULL
3358 };
3359
3360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3362 if (SWIG_arg_fail(1)) SWIG_fail;
3363 {
3364 arg2 = (int)(SWIG_As_int(obj1));
3365 if (SWIG_arg_fail(2)) SWIG_fail;
3366 }
3367 if (arg1) (arg1)->y = arg2;
3368
3369 Py_INCREF(Py_None); resultobj = Py_None;
3370 return resultobj;
3371 fail:
3372 return NULL;
3373 }
3374
3375
3376 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3377 PyObject *resultobj;
3378 wxSize *arg1 = (wxSize *) 0 ;
3379 int result;
3380 PyObject * obj0 = 0 ;
3381 char *kwnames[] = {
3382 (char *) "self", NULL
3383 };
3384
3385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3387 if (SWIG_arg_fail(1)) SWIG_fail;
3388 result = (int) ((arg1)->y);
3389
3390 {
3391 resultobj = SWIG_From_int((int)(result));
3392 }
3393 return resultobj;
3394 fail:
3395 return NULL;
3396 }
3397
3398
3399 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3400 PyObject *resultobj;
3401 int arg1 = (int) 0 ;
3402 int arg2 = (int) 0 ;
3403 wxSize *result;
3404 PyObject * obj0 = 0 ;
3405 PyObject * obj1 = 0 ;
3406 char *kwnames[] = {
3407 (char *) "w",(char *) "h", NULL
3408 };
3409
3410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3411 if (obj0) {
3412 {
3413 arg1 = (int)(SWIG_As_int(obj0));
3414 if (SWIG_arg_fail(1)) SWIG_fail;
3415 }
3416 }
3417 if (obj1) {
3418 {
3419 arg2 = (int)(SWIG_As_int(obj1));
3420 if (SWIG_arg_fail(2)) SWIG_fail;
3421 }
3422 }
3423 {
3424 PyThreadState* __tstate = wxPyBeginAllowThreads();
3425 result = (wxSize *)new wxSize(arg1,arg2);
3426
3427 wxPyEndAllowThreads(__tstate);
3428 if (PyErr_Occurred()) SWIG_fail;
3429 }
3430 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3431 return resultobj;
3432 fail:
3433 return NULL;
3434 }
3435
3436
3437 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3438 PyObject *resultobj;
3439 wxSize *arg1 = (wxSize *) 0 ;
3440 PyObject * obj0 = 0 ;
3441 char *kwnames[] = {
3442 (char *) "self", NULL
3443 };
3444
3445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3447 if (SWIG_arg_fail(1)) SWIG_fail;
3448 {
3449 PyThreadState* __tstate = wxPyBeginAllowThreads();
3450 delete arg1;
3451
3452 wxPyEndAllowThreads(__tstate);
3453 if (PyErr_Occurred()) SWIG_fail;
3454 }
3455 Py_INCREF(Py_None); resultobj = Py_None;
3456 return resultobj;
3457 fail:
3458 return NULL;
3459 }
3460
3461
3462 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3463 PyObject *resultobj;
3464 wxSize *arg1 = (wxSize *) 0 ;
3465 wxSize *arg2 = 0 ;
3466 bool result;
3467 wxSize temp2 ;
3468 PyObject * obj0 = 0 ;
3469 PyObject * obj1 = 0 ;
3470 char *kwnames[] = {
3471 (char *) "self",(char *) "sz", NULL
3472 };
3473
3474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3476 if (SWIG_arg_fail(1)) SWIG_fail;
3477 {
3478 arg2 = &temp2;
3479 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3480 }
3481 {
3482 PyThreadState* __tstate = wxPyBeginAllowThreads();
3483 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3484
3485 wxPyEndAllowThreads(__tstate);
3486 if (PyErr_Occurred()) SWIG_fail;
3487 }
3488 {
3489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3490 }
3491 return resultobj;
3492 fail:
3493 return NULL;
3494 }
3495
3496
3497 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3498 PyObject *resultobj;
3499 wxSize *arg1 = (wxSize *) 0 ;
3500 wxSize *arg2 = 0 ;
3501 bool result;
3502 wxSize temp2 ;
3503 PyObject * obj0 = 0 ;
3504 PyObject * obj1 = 0 ;
3505 char *kwnames[] = {
3506 (char *) "self",(char *) "sz", NULL
3507 };
3508
3509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3511 if (SWIG_arg_fail(1)) SWIG_fail;
3512 {
3513 arg2 = &temp2;
3514 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3515 }
3516 {
3517 PyThreadState* __tstate = wxPyBeginAllowThreads();
3518 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3519
3520 wxPyEndAllowThreads(__tstate);
3521 if (PyErr_Occurred()) SWIG_fail;
3522 }
3523 {
3524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3525 }
3526 return resultobj;
3527 fail:
3528 return NULL;
3529 }
3530
3531
3532 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3533 PyObject *resultobj;
3534 wxSize *arg1 = (wxSize *) 0 ;
3535 wxSize *arg2 = 0 ;
3536 wxSize result;
3537 wxSize temp2 ;
3538 PyObject * obj0 = 0 ;
3539 PyObject * obj1 = 0 ;
3540 char *kwnames[] = {
3541 (char *) "self",(char *) "sz", NULL
3542 };
3543
3544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3546 if (SWIG_arg_fail(1)) SWIG_fail;
3547 {
3548 arg2 = &temp2;
3549 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3550 }
3551 {
3552 PyThreadState* __tstate = wxPyBeginAllowThreads();
3553 result = (arg1)->operator +((wxSize const &)*arg2);
3554
3555 wxPyEndAllowThreads(__tstate);
3556 if (PyErr_Occurred()) SWIG_fail;
3557 }
3558 {
3559 wxSize * resultptr;
3560 resultptr = new wxSize((wxSize &)(result));
3561 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3562 }
3563 return resultobj;
3564 fail:
3565 return NULL;
3566 }
3567
3568
3569 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3570 PyObject *resultobj;
3571 wxSize *arg1 = (wxSize *) 0 ;
3572 wxSize *arg2 = 0 ;
3573 wxSize result;
3574 wxSize temp2 ;
3575 PyObject * obj0 = 0 ;
3576 PyObject * obj1 = 0 ;
3577 char *kwnames[] = {
3578 (char *) "self",(char *) "sz", NULL
3579 };
3580
3581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3583 if (SWIG_arg_fail(1)) SWIG_fail;
3584 {
3585 arg2 = &temp2;
3586 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3587 }
3588 {
3589 PyThreadState* __tstate = wxPyBeginAllowThreads();
3590 result = (arg1)->operator -((wxSize const &)*arg2);
3591
3592 wxPyEndAllowThreads(__tstate);
3593 if (PyErr_Occurred()) SWIG_fail;
3594 }
3595 {
3596 wxSize * resultptr;
3597 resultptr = new wxSize((wxSize &)(result));
3598 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3599 }
3600 return resultobj;
3601 fail:
3602 return NULL;
3603 }
3604
3605
3606 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3607 PyObject *resultobj;
3608 wxSize *arg1 = (wxSize *) 0 ;
3609 wxSize *arg2 = 0 ;
3610 wxSize temp2 ;
3611 PyObject * obj0 = 0 ;
3612 PyObject * obj1 = 0 ;
3613 char *kwnames[] = {
3614 (char *) "self",(char *) "sz", NULL
3615 };
3616
3617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3619 if (SWIG_arg_fail(1)) SWIG_fail;
3620 {
3621 arg2 = &temp2;
3622 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3623 }
3624 {
3625 PyThreadState* __tstate = wxPyBeginAllowThreads();
3626 (arg1)->IncTo((wxSize const &)*arg2);
3627
3628 wxPyEndAllowThreads(__tstate);
3629 if (PyErr_Occurred()) SWIG_fail;
3630 }
3631 Py_INCREF(Py_None); resultobj = Py_None;
3632 return resultobj;
3633 fail:
3634 return NULL;
3635 }
3636
3637
3638 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3639 PyObject *resultobj;
3640 wxSize *arg1 = (wxSize *) 0 ;
3641 wxSize *arg2 = 0 ;
3642 wxSize temp2 ;
3643 PyObject * obj0 = 0 ;
3644 PyObject * obj1 = 0 ;
3645 char *kwnames[] = {
3646 (char *) "self",(char *) "sz", NULL
3647 };
3648
3649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3651 if (SWIG_arg_fail(1)) SWIG_fail;
3652 {
3653 arg2 = &temp2;
3654 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3655 }
3656 {
3657 PyThreadState* __tstate = wxPyBeginAllowThreads();
3658 (arg1)->DecTo((wxSize const &)*arg2);
3659
3660 wxPyEndAllowThreads(__tstate);
3661 if (PyErr_Occurred()) SWIG_fail;
3662 }
3663 Py_INCREF(Py_None); resultobj = Py_None;
3664 return resultobj;
3665 fail:
3666 return NULL;
3667 }
3668
3669
3670 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3671 PyObject *resultobj;
3672 wxSize *arg1 = (wxSize *) 0 ;
3673 int arg2 ;
3674 int arg3 ;
3675 PyObject * obj0 = 0 ;
3676 PyObject * obj1 = 0 ;
3677 PyObject * obj2 = 0 ;
3678 char *kwnames[] = {
3679 (char *) "self",(char *) "w",(char *) "h", NULL
3680 };
3681
3682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3684 if (SWIG_arg_fail(1)) SWIG_fail;
3685 {
3686 arg2 = (int)(SWIG_As_int(obj1));
3687 if (SWIG_arg_fail(2)) SWIG_fail;
3688 }
3689 {
3690 arg3 = (int)(SWIG_As_int(obj2));
3691 if (SWIG_arg_fail(3)) SWIG_fail;
3692 }
3693 {
3694 PyThreadState* __tstate = wxPyBeginAllowThreads();
3695 (arg1)->Set(arg2,arg3);
3696
3697 wxPyEndAllowThreads(__tstate);
3698 if (PyErr_Occurred()) SWIG_fail;
3699 }
3700 Py_INCREF(Py_None); resultobj = Py_None;
3701 return resultobj;
3702 fail:
3703 return NULL;
3704 }
3705
3706
3707 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3708 PyObject *resultobj;
3709 wxSize *arg1 = (wxSize *) 0 ;
3710 int arg2 ;
3711 PyObject * obj0 = 0 ;
3712 PyObject * obj1 = 0 ;
3713 char *kwnames[] = {
3714 (char *) "self",(char *) "w", NULL
3715 };
3716
3717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3719 if (SWIG_arg_fail(1)) SWIG_fail;
3720 {
3721 arg2 = (int)(SWIG_As_int(obj1));
3722 if (SWIG_arg_fail(2)) SWIG_fail;
3723 }
3724 {
3725 PyThreadState* __tstate = wxPyBeginAllowThreads();
3726 (arg1)->SetWidth(arg2);
3727
3728 wxPyEndAllowThreads(__tstate);
3729 if (PyErr_Occurred()) SWIG_fail;
3730 }
3731 Py_INCREF(Py_None); resultobj = Py_None;
3732 return resultobj;
3733 fail:
3734 return NULL;
3735 }
3736
3737
3738 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3739 PyObject *resultobj;
3740 wxSize *arg1 = (wxSize *) 0 ;
3741 int arg2 ;
3742 PyObject * obj0 = 0 ;
3743 PyObject * obj1 = 0 ;
3744 char *kwnames[] = {
3745 (char *) "self",(char *) "h", NULL
3746 };
3747
3748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3750 if (SWIG_arg_fail(1)) SWIG_fail;
3751 {
3752 arg2 = (int)(SWIG_As_int(obj1));
3753 if (SWIG_arg_fail(2)) SWIG_fail;
3754 }
3755 {
3756 PyThreadState* __tstate = wxPyBeginAllowThreads();
3757 (arg1)->SetHeight(arg2);
3758
3759 wxPyEndAllowThreads(__tstate);
3760 if (PyErr_Occurred()) SWIG_fail;
3761 }
3762 Py_INCREF(Py_None); resultobj = Py_None;
3763 return resultobj;
3764 fail:
3765 return NULL;
3766 }
3767
3768
3769 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3770 PyObject *resultobj;
3771 wxSize *arg1 = (wxSize *) 0 ;
3772 int result;
3773 PyObject * obj0 = 0 ;
3774 char *kwnames[] = {
3775 (char *) "self", NULL
3776 };
3777
3778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3780 if (SWIG_arg_fail(1)) SWIG_fail;
3781 {
3782 PyThreadState* __tstate = wxPyBeginAllowThreads();
3783 result = (int)((wxSize const *)arg1)->GetWidth();
3784
3785 wxPyEndAllowThreads(__tstate);
3786 if (PyErr_Occurred()) SWIG_fail;
3787 }
3788 {
3789 resultobj = SWIG_From_int((int)(result));
3790 }
3791 return resultobj;
3792 fail:
3793 return NULL;
3794 }
3795
3796
3797 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3798 PyObject *resultobj;
3799 wxSize *arg1 = (wxSize *) 0 ;
3800 int result;
3801 PyObject * obj0 = 0 ;
3802 char *kwnames[] = {
3803 (char *) "self", NULL
3804 };
3805
3806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3808 if (SWIG_arg_fail(1)) SWIG_fail;
3809 {
3810 PyThreadState* __tstate = wxPyBeginAllowThreads();
3811 result = (int)((wxSize const *)arg1)->GetHeight();
3812
3813 wxPyEndAllowThreads(__tstate);
3814 if (PyErr_Occurred()) SWIG_fail;
3815 }
3816 {
3817 resultobj = SWIG_From_int((int)(result));
3818 }
3819 return resultobj;
3820 fail:
3821 return NULL;
3822 }
3823
3824
3825 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3826 PyObject *resultobj;
3827 wxSize *arg1 = (wxSize *) 0 ;
3828 bool result;
3829 PyObject * obj0 = 0 ;
3830 char *kwnames[] = {
3831 (char *) "self", NULL
3832 };
3833
3834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3836 if (SWIG_arg_fail(1)) SWIG_fail;
3837 {
3838 PyThreadState* __tstate = wxPyBeginAllowThreads();
3839 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3840
3841 wxPyEndAllowThreads(__tstate);
3842 if (PyErr_Occurred()) SWIG_fail;
3843 }
3844 {
3845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3846 }
3847 return resultobj;
3848 fail:
3849 return NULL;
3850 }
3851
3852
3853 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3854 PyObject *resultobj;
3855 wxSize *arg1 = (wxSize *) 0 ;
3856 wxSize *arg2 = 0 ;
3857 wxSize temp2 ;
3858 PyObject * obj0 = 0 ;
3859 PyObject * obj1 = 0 ;
3860 char *kwnames[] = {
3861 (char *) "self",(char *) "size", NULL
3862 };
3863
3864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3866 if (SWIG_arg_fail(1)) SWIG_fail;
3867 {
3868 arg2 = &temp2;
3869 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3870 }
3871 {
3872 PyThreadState* __tstate = wxPyBeginAllowThreads();
3873 (arg1)->SetDefaults((wxSize const &)*arg2);
3874
3875 wxPyEndAllowThreads(__tstate);
3876 if (PyErr_Occurred()) SWIG_fail;
3877 }
3878 Py_INCREF(Py_None); resultobj = Py_None;
3879 return resultobj;
3880 fail:
3881 return NULL;
3882 }
3883
3884
3885 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3886 PyObject *resultobj;
3887 wxSize *arg1 = (wxSize *) 0 ;
3888 PyObject *result;
3889 PyObject * obj0 = 0 ;
3890 char *kwnames[] = {
3891 (char *) "self", NULL
3892 };
3893
3894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3896 if (SWIG_arg_fail(1)) SWIG_fail;
3897 {
3898 PyThreadState* __tstate = wxPyBeginAllowThreads();
3899 result = (PyObject *)wxSize_Get(arg1);
3900
3901 wxPyEndAllowThreads(__tstate);
3902 if (PyErr_Occurred()) SWIG_fail;
3903 }
3904 resultobj = result;
3905 return resultobj;
3906 fail:
3907 return NULL;
3908 }
3909
3910
3911 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3912 PyObject *obj;
3913 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3914 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3915 Py_INCREF(obj);
3916 return Py_BuildValue((char *)"");
3917 }
3918 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3919 PyObject *resultobj;
3920 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3921 double arg2 ;
3922 PyObject * obj0 = 0 ;
3923 PyObject * obj1 = 0 ;
3924 char *kwnames[] = {
3925 (char *) "self",(char *) "x", NULL
3926 };
3927
3928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3930 if (SWIG_arg_fail(1)) SWIG_fail;
3931 {
3932 arg2 = (double)(SWIG_As_double(obj1));
3933 if (SWIG_arg_fail(2)) SWIG_fail;
3934 }
3935 if (arg1) (arg1)->x = arg2;
3936
3937 Py_INCREF(Py_None); resultobj = Py_None;
3938 return resultobj;
3939 fail:
3940 return NULL;
3941 }
3942
3943
3944 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3945 PyObject *resultobj;
3946 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3947 double result;
3948 PyObject * obj0 = 0 ;
3949 char *kwnames[] = {
3950 (char *) "self", NULL
3951 };
3952
3953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3955 if (SWIG_arg_fail(1)) SWIG_fail;
3956 result = (double) ((arg1)->x);
3957
3958 {
3959 resultobj = SWIG_From_double((double)(result));
3960 }
3961 return resultobj;
3962 fail:
3963 return NULL;
3964 }
3965
3966
3967 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3968 PyObject *resultobj;
3969 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3970 double arg2 ;
3971 PyObject * obj0 = 0 ;
3972 PyObject * obj1 = 0 ;
3973 char *kwnames[] = {
3974 (char *) "self",(char *) "y", NULL
3975 };
3976
3977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3979 if (SWIG_arg_fail(1)) SWIG_fail;
3980 {
3981 arg2 = (double)(SWIG_As_double(obj1));
3982 if (SWIG_arg_fail(2)) SWIG_fail;
3983 }
3984 if (arg1) (arg1)->y = arg2;
3985
3986 Py_INCREF(Py_None); resultobj = Py_None;
3987 return resultobj;
3988 fail:
3989 return NULL;
3990 }
3991
3992
3993 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
3994 PyObject *resultobj;
3995 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3996 double result;
3997 PyObject * obj0 = 0 ;
3998 char *kwnames[] = {
3999 (char *) "self", NULL
4000 };
4001
4002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4004 if (SWIG_arg_fail(1)) SWIG_fail;
4005 result = (double) ((arg1)->y);
4006
4007 {
4008 resultobj = SWIG_From_double((double)(result));
4009 }
4010 return resultobj;
4011 fail:
4012 return NULL;
4013 }
4014
4015
4016 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4017 PyObject *resultobj;
4018 double arg1 = (double) 0.0 ;
4019 double arg2 = (double) 0.0 ;
4020 wxRealPoint *result;
4021 PyObject * obj0 = 0 ;
4022 PyObject * obj1 = 0 ;
4023 char *kwnames[] = {
4024 (char *) "x",(char *) "y", NULL
4025 };
4026
4027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4028 if (obj0) {
4029 {
4030 arg1 = (double)(SWIG_As_double(obj0));
4031 if (SWIG_arg_fail(1)) SWIG_fail;
4032 }
4033 }
4034 if (obj1) {
4035 {
4036 arg2 = (double)(SWIG_As_double(obj1));
4037 if (SWIG_arg_fail(2)) SWIG_fail;
4038 }
4039 }
4040 {
4041 PyThreadState* __tstate = wxPyBeginAllowThreads();
4042 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4043
4044 wxPyEndAllowThreads(__tstate);
4045 if (PyErr_Occurred()) SWIG_fail;
4046 }
4047 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4048 return resultobj;
4049 fail:
4050 return NULL;
4051 }
4052
4053
4054 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4055 PyObject *resultobj;
4056 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4057 PyObject * obj0 = 0 ;
4058 char *kwnames[] = {
4059 (char *) "self", NULL
4060 };
4061
4062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4064 if (SWIG_arg_fail(1)) SWIG_fail;
4065 {
4066 PyThreadState* __tstate = wxPyBeginAllowThreads();
4067 delete arg1;
4068
4069 wxPyEndAllowThreads(__tstate);
4070 if (PyErr_Occurred()) SWIG_fail;
4071 }
4072 Py_INCREF(Py_None); resultobj = Py_None;
4073 return resultobj;
4074 fail:
4075 return NULL;
4076 }
4077
4078
4079 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4080 PyObject *resultobj;
4081 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4082 wxRealPoint *arg2 = 0 ;
4083 bool result;
4084 wxRealPoint temp2 ;
4085 PyObject * obj0 = 0 ;
4086 PyObject * obj1 = 0 ;
4087 char *kwnames[] = {
4088 (char *) "self",(char *) "pt", NULL
4089 };
4090
4091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4093 if (SWIG_arg_fail(1)) SWIG_fail;
4094 {
4095 arg2 = &temp2;
4096 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4097 }
4098 {
4099 PyThreadState* __tstate = wxPyBeginAllowThreads();
4100 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4101
4102 wxPyEndAllowThreads(__tstate);
4103 if (PyErr_Occurred()) SWIG_fail;
4104 }
4105 {
4106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4107 }
4108 return resultobj;
4109 fail:
4110 return NULL;
4111 }
4112
4113
4114 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4115 PyObject *resultobj;
4116 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4117 wxRealPoint *arg2 = 0 ;
4118 bool result;
4119 wxRealPoint temp2 ;
4120 PyObject * obj0 = 0 ;
4121 PyObject * obj1 = 0 ;
4122 char *kwnames[] = {
4123 (char *) "self",(char *) "pt", NULL
4124 };
4125
4126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4128 if (SWIG_arg_fail(1)) SWIG_fail;
4129 {
4130 arg2 = &temp2;
4131 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4132 }
4133 {
4134 PyThreadState* __tstate = wxPyBeginAllowThreads();
4135 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4136
4137 wxPyEndAllowThreads(__tstate);
4138 if (PyErr_Occurred()) SWIG_fail;
4139 }
4140 {
4141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4142 }
4143 return resultobj;
4144 fail:
4145 return NULL;
4146 }
4147
4148
4149 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4150 PyObject *resultobj;
4151 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4152 wxRealPoint *arg2 = 0 ;
4153 wxRealPoint result;
4154 wxRealPoint temp2 ;
4155 PyObject * obj0 = 0 ;
4156 PyObject * obj1 = 0 ;
4157 char *kwnames[] = {
4158 (char *) "self",(char *) "pt", NULL
4159 };
4160
4161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4163 if (SWIG_arg_fail(1)) SWIG_fail;
4164 {
4165 arg2 = &temp2;
4166 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4167 }
4168 {
4169 PyThreadState* __tstate = wxPyBeginAllowThreads();
4170 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4171
4172 wxPyEndAllowThreads(__tstate);
4173 if (PyErr_Occurred()) SWIG_fail;
4174 }
4175 {
4176 wxRealPoint * resultptr;
4177 resultptr = new wxRealPoint((wxRealPoint &)(result));
4178 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4179 }
4180 return resultobj;
4181 fail:
4182 return NULL;
4183 }
4184
4185
4186 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4187 PyObject *resultobj;
4188 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4189 wxRealPoint *arg2 = 0 ;
4190 wxRealPoint result;
4191 wxRealPoint temp2 ;
4192 PyObject * obj0 = 0 ;
4193 PyObject * obj1 = 0 ;
4194 char *kwnames[] = {
4195 (char *) "self",(char *) "pt", NULL
4196 };
4197
4198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4200 if (SWIG_arg_fail(1)) SWIG_fail;
4201 {
4202 arg2 = &temp2;
4203 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4204 }
4205 {
4206 PyThreadState* __tstate = wxPyBeginAllowThreads();
4207 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4208
4209 wxPyEndAllowThreads(__tstate);
4210 if (PyErr_Occurred()) SWIG_fail;
4211 }
4212 {
4213 wxRealPoint * resultptr;
4214 resultptr = new wxRealPoint((wxRealPoint &)(result));
4215 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4216 }
4217 return resultobj;
4218 fail:
4219 return NULL;
4220 }
4221
4222
4223 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4224 PyObject *resultobj;
4225 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4226 double arg2 ;
4227 double arg3 ;
4228 PyObject * obj0 = 0 ;
4229 PyObject * obj1 = 0 ;
4230 PyObject * obj2 = 0 ;
4231 char *kwnames[] = {
4232 (char *) "self",(char *) "x",(char *) "y", NULL
4233 };
4234
4235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4237 if (SWIG_arg_fail(1)) SWIG_fail;
4238 {
4239 arg2 = (double)(SWIG_As_double(obj1));
4240 if (SWIG_arg_fail(2)) SWIG_fail;
4241 }
4242 {
4243 arg3 = (double)(SWIG_As_double(obj2));
4244 if (SWIG_arg_fail(3)) SWIG_fail;
4245 }
4246 {
4247 PyThreadState* __tstate = wxPyBeginAllowThreads();
4248 wxRealPoint_Set(arg1,arg2,arg3);
4249
4250 wxPyEndAllowThreads(__tstate);
4251 if (PyErr_Occurred()) SWIG_fail;
4252 }
4253 Py_INCREF(Py_None); resultobj = Py_None;
4254 return resultobj;
4255 fail:
4256 return NULL;
4257 }
4258
4259
4260 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4261 PyObject *resultobj;
4262 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4263 PyObject *result;
4264 PyObject * obj0 = 0 ;
4265 char *kwnames[] = {
4266 (char *) "self", NULL
4267 };
4268
4269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4271 if (SWIG_arg_fail(1)) SWIG_fail;
4272 {
4273 PyThreadState* __tstate = wxPyBeginAllowThreads();
4274 result = (PyObject *)wxRealPoint_Get(arg1);
4275
4276 wxPyEndAllowThreads(__tstate);
4277 if (PyErr_Occurred()) SWIG_fail;
4278 }
4279 resultobj = result;
4280 return resultobj;
4281 fail:
4282 return NULL;
4283 }
4284
4285
4286 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4287 PyObject *obj;
4288 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4289 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4290 Py_INCREF(obj);
4291 return Py_BuildValue((char *)"");
4292 }
4293 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4294 PyObject *resultobj;
4295 wxPoint *arg1 = (wxPoint *) 0 ;
4296 int arg2 ;
4297 PyObject * obj0 = 0 ;
4298 PyObject * obj1 = 0 ;
4299 char *kwnames[] = {
4300 (char *) "self",(char *) "x", NULL
4301 };
4302
4303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4305 if (SWIG_arg_fail(1)) SWIG_fail;
4306 {
4307 arg2 = (int)(SWIG_As_int(obj1));
4308 if (SWIG_arg_fail(2)) SWIG_fail;
4309 }
4310 if (arg1) (arg1)->x = arg2;
4311
4312 Py_INCREF(Py_None); resultobj = Py_None;
4313 return resultobj;
4314 fail:
4315 return NULL;
4316 }
4317
4318
4319 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4320 PyObject *resultobj;
4321 wxPoint *arg1 = (wxPoint *) 0 ;
4322 int result;
4323 PyObject * obj0 = 0 ;
4324 char *kwnames[] = {
4325 (char *) "self", NULL
4326 };
4327
4328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4330 if (SWIG_arg_fail(1)) SWIG_fail;
4331 result = (int) ((arg1)->x);
4332
4333 {
4334 resultobj = SWIG_From_int((int)(result));
4335 }
4336 return resultobj;
4337 fail:
4338 return NULL;
4339 }
4340
4341
4342 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4343 PyObject *resultobj;
4344 wxPoint *arg1 = (wxPoint *) 0 ;
4345 int arg2 ;
4346 PyObject * obj0 = 0 ;
4347 PyObject * obj1 = 0 ;
4348 char *kwnames[] = {
4349 (char *) "self",(char *) "y", NULL
4350 };
4351
4352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4354 if (SWIG_arg_fail(1)) SWIG_fail;
4355 {
4356 arg2 = (int)(SWIG_As_int(obj1));
4357 if (SWIG_arg_fail(2)) SWIG_fail;
4358 }
4359 if (arg1) (arg1)->y = arg2;
4360
4361 Py_INCREF(Py_None); resultobj = Py_None;
4362 return resultobj;
4363 fail:
4364 return NULL;
4365 }
4366
4367
4368 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4369 PyObject *resultobj;
4370 wxPoint *arg1 = (wxPoint *) 0 ;
4371 int result;
4372 PyObject * obj0 = 0 ;
4373 char *kwnames[] = {
4374 (char *) "self", NULL
4375 };
4376
4377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4379 if (SWIG_arg_fail(1)) SWIG_fail;
4380 result = (int) ((arg1)->y);
4381
4382 {
4383 resultobj = SWIG_From_int((int)(result));
4384 }
4385 return resultobj;
4386 fail:
4387 return NULL;
4388 }
4389
4390
4391 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4392 PyObject *resultobj;
4393 int arg1 = (int) 0 ;
4394 int arg2 = (int) 0 ;
4395 wxPoint *result;
4396 PyObject * obj0 = 0 ;
4397 PyObject * obj1 = 0 ;
4398 char *kwnames[] = {
4399 (char *) "x",(char *) "y", NULL
4400 };
4401
4402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4403 if (obj0) {
4404 {
4405 arg1 = (int)(SWIG_As_int(obj0));
4406 if (SWIG_arg_fail(1)) SWIG_fail;
4407 }
4408 }
4409 if (obj1) {
4410 {
4411 arg2 = (int)(SWIG_As_int(obj1));
4412 if (SWIG_arg_fail(2)) SWIG_fail;
4413 }
4414 }
4415 {
4416 PyThreadState* __tstate = wxPyBeginAllowThreads();
4417 result = (wxPoint *)new wxPoint(arg1,arg2);
4418
4419 wxPyEndAllowThreads(__tstate);
4420 if (PyErr_Occurred()) SWIG_fail;
4421 }
4422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4423 return resultobj;
4424 fail:
4425 return NULL;
4426 }
4427
4428
4429 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4430 PyObject *resultobj;
4431 wxPoint *arg1 = (wxPoint *) 0 ;
4432 PyObject * obj0 = 0 ;
4433 char *kwnames[] = {
4434 (char *) "self", NULL
4435 };
4436
4437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4439 if (SWIG_arg_fail(1)) SWIG_fail;
4440 {
4441 PyThreadState* __tstate = wxPyBeginAllowThreads();
4442 delete arg1;
4443
4444 wxPyEndAllowThreads(__tstate);
4445 if (PyErr_Occurred()) SWIG_fail;
4446 }
4447 Py_INCREF(Py_None); resultobj = Py_None;
4448 return resultobj;
4449 fail:
4450 return NULL;
4451 }
4452
4453
4454 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4455 PyObject *resultobj;
4456 wxPoint *arg1 = (wxPoint *) 0 ;
4457 wxPoint *arg2 = 0 ;
4458 bool result;
4459 wxPoint temp2 ;
4460 PyObject * obj0 = 0 ;
4461 PyObject * obj1 = 0 ;
4462 char *kwnames[] = {
4463 (char *) "self",(char *) "pt", NULL
4464 };
4465
4466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4468 if (SWIG_arg_fail(1)) SWIG_fail;
4469 {
4470 arg2 = &temp2;
4471 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4472 }
4473 {
4474 PyThreadState* __tstate = wxPyBeginAllowThreads();
4475 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4476
4477 wxPyEndAllowThreads(__tstate);
4478 if (PyErr_Occurred()) SWIG_fail;
4479 }
4480 {
4481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4482 }
4483 return resultobj;
4484 fail:
4485 return NULL;
4486 }
4487
4488
4489 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4490 PyObject *resultobj;
4491 wxPoint *arg1 = (wxPoint *) 0 ;
4492 wxPoint *arg2 = 0 ;
4493 bool result;
4494 wxPoint temp2 ;
4495 PyObject * obj0 = 0 ;
4496 PyObject * obj1 = 0 ;
4497 char *kwnames[] = {
4498 (char *) "self",(char *) "pt", NULL
4499 };
4500
4501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4503 if (SWIG_arg_fail(1)) SWIG_fail;
4504 {
4505 arg2 = &temp2;
4506 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4507 }
4508 {
4509 PyThreadState* __tstate = wxPyBeginAllowThreads();
4510 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4511
4512 wxPyEndAllowThreads(__tstate);
4513 if (PyErr_Occurred()) SWIG_fail;
4514 }
4515 {
4516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4517 }
4518 return resultobj;
4519 fail:
4520 return NULL;
4521 }
4522
4523
4524 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4525 PyObject *resultobj;
4526 wxPoint *arg1 = (wxPoint *) 0 ;
4527 wxPoint *arg2 = 0 ;
4528 wxPoint result;
4529 wxPoint temp2 ;
4530 PyObject * obj0 = 0 ;
4531 PyObject * obj1 = 0 ;
4532 char *kwnames[] = {
4533 (char *) "self",(char *) "pt", NULL
4534 };
4535
4536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4538 if (SWIG_arg_fail(1)) SWIG_fail;
4539 {
4540 arg2 = &temp2;
4541 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4542 }
4543 {
4544 PyThreadState* __tstate = wxPyBeginAllowThreads();
4545 result = (arg1)->operator +((wxPoint const &)*arg2);
4546
4547 wxPyEndAllowThreads(__tstate);
4548 if (PyErr_Occurred()) SWIG_fail;
4549 }
4550 {
4551 wxPoint * resultptr;
4552 resultptr = new wxPoint((wxPoint &)(result));
4553 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4554 }
4555 return resultobj;
4556 fail:
4557 return NULL;
4558 }
4559
4560
4561 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4562 PyObject *resultobj;
4563 wxPoint *arg1 = (wxPoint *) 0 ;
4564 wxPoint *arg2 = 0 ;
4565 wxPoint result;
4566 wxPoint temp2 ;
4567 PyObject * obj0 = 0 ;
4568 PyObject * obj1 = 0 ;
4569 char *kwnames[] = {
4570 (char *) "self",(char *) "pt", NULL
4571 };
4572
4573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4575 if (SWIG_arg_fail(1)) SWIG_fail;
4576 {
4577 arg2 = &temp2;
4578 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4579 }
4580 {
4581 PyThreadState* __tstate = wxPyBeginAllowThreads();
4582 result = (arg1)->operator -((wxPoint const &)*arg2);
4583
4584 wxPyEndAllowThreads(__tstate);
4585 if (PyErr_Occurred()) SWIG_fail;
4586 }
4587 {
4588 wxPoint * resultptr;
4589 resultptr = new wxPoint((wxPoint &)(result));
4590 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4591 }
4592 return resultobj;
4593 fail:
4594 return NULL;
4595 }
4596
4597
4598 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4599 PyObject *resultobj;
4600 wxPoint *arg1 = (wxPoint *) 0 ;
4601 wxPoint *arg2 = 0 ;
4602 wxPoint *result;
4603 wxPoint temp2 ;
4604 PyObject * obj0 = 0 ;
4605 PyObject * obj1 = 0 ;
4606 char *kwnames[] = {
4607 (char *) "self",(char *) "pt", NULL
4608 };
4609
4610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4612 if (SWIG_arg_fail(1)) SWIG_fail;
4613 {
4614 arg2 = &temp2;
4615 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4616 }
4617 {
4618 PyThreadState* __tstate = wxPyBeginAllowThreads();
4619 {
4620 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4621 result = (wxPoint *) &_result_ref;
4622 }
4623
4624 wxPyEndAllowThreads(__tstate);
4625 if (PyErr_Occurred()) SWIG_fail;
4626 }
4627 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4628 return resultobj;
4629 fail:
4630 return NULL;
4631 }
4632
4633
4634 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4635 PyObject *resultobj;
4636 wxPoint *arg1 = (wxPoint *) 0 ;
4637 wxPoint *arg2 = 0 ;
4638 wxPoint *result;
4639 wxPoint temp2 ;
4640 PyObject * obj0 = 0 ;
4641 PyObject * obj1 = 0 ;
4642 char *kwnames[] = {
4643 (char *) "self",(char *) "pt", NULL
4644 };
4645
4646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4648 if (SWIG_arg_fail(1)) SWIG_fail;
4649 {
4650 arg2 = &temp2;
4651 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4652 }
4653 {
4654 PyThreadState* __tstate = wxPyBeginAllowThreads();
4655 {
4656 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4657 result = (wxPoint *) &_result_ref;
4658 }
4659
4660 wxPyEndAllowThreads(__tstate);
4661 if (PyErr_Occurred()) SWIG_fail;
4662 }
4663 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4664 return resultobj;
4665 fail:
4666 return NULL;
4667 }
4668
4669
4670 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4671 PyObject *resultobj;
4672 wxPoint *arg1 = (wxPoint *) 0 ;
4673 long arg2 ;
4674 long arg3 ;
4675 PyObject * obj0 = 0 ;
4676 PyObject * obj1 = 0 ;
4677 PyObject * obj2 = 0 ;
4678 char *kwnames[] = {
4679 (char *) "self",(char *) "x",(char *) "y", NULL
4680 };
4681
4682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4684 if (SWIG_arg_fail(1)) SWIG_fail;
4685 {
4686 arg2 = (long)(SWIG_As_long(obj1));
4687 if (SWIG_arg_fail(2)) SWIG_fail;
4688 }
4689 {
4690 arg3 = (long)(SWIG_As_long(obj2));
4691 if (SWIG_arg_fail(3)) SWIG_fail;
4692 }
4693 {
4694 PyThreadState* __tstate = wxPyBeginAllowThreads();
4695 wxPoint_Set(arg1,arg2,arg3);
4696
4697 wxPyEndAllowThreads(__tstate);
4698 if (PyErr_Occurred()) SWIG_fail;
4699 }
4700 Py_INCREF(Py_None); resultobj = Py_None;
4701 return resultobj;
4702 fail:
4703 return NULL;
4704 }
4705
4706
4707 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4708 PyObject *resultobj;
4709 wxPoint *arg1 = (wxPoint *) 0 ;
4710 PyObject *result;
4711 PyObject * obj0 = 0 ;
4712 char *kwnames[] = {
4713 (char *) "self", NULL
4714 };
4715
4716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4718 if (SWIG_arg_fail(1)) SWIG_fail;
4719 {
4720 PyThreadState* __tstate = wxPyBeginAllowThreads();
4721 result = (PyObject *)wxPoint_Get(arg1);
4722
4723 wxPyEndAllowThreads(__tstate);
4724 if (PyErr_Occurred()) SWIG_fail;
4725 }
4726 resultobj = result;
4727 return resultobj;
4728 fail:
4729 return NULL;
4730 }
4731
4732
4733 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4734 PyObject *obj;
4735 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4736 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4737 Py_INCREF(obj);
4738 return Py_BuildValue((char *)"");
4739 }
4740 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4741 PyObject *resultobj;
4742 int arg1 = (int) 0 ;
4743 int arg2 = (int) 0 ;
4744 int arg3 = (int) 0 ;
4745 int arg4 = (int) 0 ;
4746 wxRect *result;
4747 PyObject * obj0 = 0 ;
4748 PyObject * obj1 = 0 ;
4749 PyObject * obj2 = 0 ;
4750 PyObject * obj3 = 0 ;
4751 char *kwnames[] = {
4752 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4753 };
4754
4755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4756 if (obj0) {
4757 {
4758 arg1 = (int)(SWIG_As_int(obj0));
4759 if (SWIG_arg_fail(1)) SWIG_fail;
4760 }
4761 }
4762 if (obj1) {
4763 {
4764 arg2 = (int)(SWIG_As_int(obj1));
4765 if (SWIG_arg_fail(2)) SWIG_fail;
4766 }
4767 }
4768 if (obj2) {
4769 {
4770 arg3 = (int)(SWIG_As_int(obj2));
4771 if (SWIG_arg_fail(3)) SWIG_fail;
4772 }
4773 }
4774 if (obj3) {
4775 {
4776 arg4 = (int)(SWIG_As_int(obj3));
4777 if (SWIG_arg_fail(4)) SWIG_fail;
4778 }
4779 }
4780 {
4781 PyThreadState* __tstate = wxPyBeginAllowThreads();
4782 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4783
4784 wxPyEndAllowThreads(__tstate);
4785 if (PyErr_Occurred()) SWIG_fail;
4786 }
4787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4788 return resultobj;
4789 fail:
4790 return NULL;
4791 }
4792
4793
4794 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4795 PyObject *resultobj;
4796 wxPoint *arg1 = 0 ;
4797 wxPoint *arg2 = 0 ;
4798 wxRect *result;
4799 wxPoint temp1 ;
4800 wxPoint temp2 ;
4801 PyObject * obj0 = 0 ;
4802 PyObject * obj1 = 0 ;
4803 char *kwnames[] = {
4804 (char *) "topLeft",(char *) "bottomRight", NULL
4805 };
4806
4807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4808 {
4809 arg1 = &temp1;
4810 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4811 }
4812 {
4813 arg2 = &temp2;
4814 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4815 }
4816 {
4817 PyThreadState* __tstate = wxPyBeginAllowThreads();
4818 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4819
4820 wxPyEndAllowThreads(__tstate);
4821 if (PyErr_Occurred()) SWIG_fail;
4822 }
4823 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4824 return resultobj;
4825 fail:
4826 return NULL;
4827 }
4828
4829
4830 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4831 PyObject *resultobj;
4832 wxPoint *arg1 = 0 ;
4833 wxSize *arg2 = 0 ;
4834 wxRect *result;
4835 wxPoint temp1 ;
4836 wxSize temp2 ;
4837 PyObject * obj0 = 0 ;
4838 PyObject * obj1 = 0 ;
4839 char *kwnames[] = {
4840 (char *) "pos",(char *) "size", NULL
4841 };
4842
4843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4844 {
4845 arg1 = &temp1;
4846 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4847 }
4848 {
4849 arg2 = &temp2;
4850 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4851 }
4852 {
4853 PyThreadState* __tstate = wxPyBeginAllowThreads();
4854 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4855
4856 wxPyEndAllowThreads(__tstate);
4857 if (PyErr_Occurred()) SWIG_fail;
4858 }
4859 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4860 return resultobj;
4861 fail:
4862 return NULL;
4863 }
4864
4865
4866 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4867 PyObject *resultobj;
4868 wxSize *arg1 = 0 ;
4869 wxRect *result;
4870 wxSize temp1 ;
4871 PyObject * obj0 = 0 ;
4872 char *kwnames[] = {
4873 (char *) "size", NULL
4874 };
4875
4876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4877 {
4878 arg1 = &temp1;
4879 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4880 }
4881 {
4882 PyThreadState* __tstate = wxPyBeginAllowThreads();
4883 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4884
4885 wxPyEndAllowThreads(__tstate);
4886 if (PyErr_Occurred()) SWIG_fail;
4887 }
4888 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4889 return resultobj;
4890 fail:
4891 return NULL;
4892 }
4893
4894
4895 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4896 PyObject *resultobj;
4897 wxRect *arg1 = (wxRect *) 0 ;
4898 PyObject * obj0 = 0 ;
4899 char *kwnames[] = {
4900 (char *) "self", NULL
4901 };
4902
4903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4905 if (SWIG_arg_fail(1)) SWIG_fail;
4906 {
4907 PyThreadState* __tstate = wxPyBeginAllowThreads();
4908 delete arg1;
4909
4910 wxPyEndAllowThreads(__tstate);
4911 if (PyErr_Occurred()) SWIG_fail;
4912 }
4913 Py_INCREF(Py_None); resultobj = Py_None;
4914 return resultobj;
4915 fail:
4916 return NULL;
4917 }
4918
4919
4920 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4921 PyObject *resultobj;
4922 wxRect *arg1 = (wxRect *) 0 ;
4923 int result;
4924 PyObject * obj0 = 0 ;
4925 char *kwnames[] = {
4926 (char *) "self", NULL
4927 };
4928
4929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4931 if (SWIG_arg_fail(1)) SWIG_fail;
4932 {
4933 PyThreadState* __tstate = wxPyBeginAllowThreads();
4934 result = (int)((wxRect const *)arg1)->GetX();
4935
4936 wxPyEndAllowThreads(__tstate);
4937 if (PyErr_Occurred()) SWIG_fail;
4938 }
4939 {
4940 resultobj = SWIG_From_int((int)(result));
4941 }
4942 return resultobj;
4943 fail:
4944 return NULL;
4945 }
4946
4947
4948 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4949 PyObject *resultobj;
4950 wxRect *arg1 = (wxRect *) 0 ;
4951 int arg2 ;
4952 PyObject * obj0 = 0 ;
4953 PyObject * obj1 = 0 ;
4954 char *kwnames[] = {
4955 (char *) "self",(char *) "x", NULL
4956 };
4957
4958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4960 if (SWIG_arg_fail(1)) SWIG_fail;
4961 {
4962 arg2 = (int)(SWIG_As_int(obj1));
4963 if (SWIG_arg_fail(2)) SWIG_fail;
4964 }
4965 {
4966 PyThreadState* __tstate = wxPyBeginAllowThreads();
4967 (arg1)->SetX(arg2);
4968
4969 wxPyEndAllowThreads(__tstate);
4970 if (PyErr_Occurred()) SWIG_fail;
4971 }
4972 Py_INCREF(Py_None); resultobj = Py_None;
4973 return resultobj;
4974 fail:
4975 return NULL;
4976 }
4977
4978
4979 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4980 PyObject *resultobj;
4981 wxRect *arg1 = (wxRect *) 0 ;
4982 int result;
4983 PyObject * obj0 = 0 ;
4984 char *kwnames[] = {
4985 (char *) "self", NULL
4986 };
4987
4988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
4989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4990 if (SWIG_arg_fail(1)) SWIG_fail;
4991 {
4992 PyThreadState* __tstate = wxPyBeginAllowThreads();
4993 result = (int)(arg1)->GetY();
4994
4995 wxPyEndAllowThreads(__tstate);
4996 if (PyErr_Occurred()) SWIG_fail;
4997 }
4998 {
4999 resultobj = SWIG_From_int((int)(result));
5000 }
5001 return resultobj;
5002 fail:
5003 return NULL;
5004 }
5005
5006
5007 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5008 PyObject *resultobj;
5009 wxRect *arg1 = (wxRect *) 0 ;
5010 int arg2 ;
5011 PyObject * obj0 = 0 ;
5012 PyObject * obj1 = 0 ;
5013 char *kwnames[] = {
5014 (char *) "self",(char *) "y", NULL
5015 };
5016
5017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5019 if (SWIG_arg_fail(1)) SWIG_fail;
5020 {
5021 arg2 = (int)(SWIG_As_int(obj1));
5022 if (SWIG_arg_fail(2)) SWIG_fail;
5023 }
5024 {
5025 PyThreadState* __tstate = wxPyBeginAllowThreads();
5026 (arg1)->SetY(arg2);
5027
5028 wxPyEndAllowThreads(__tstate);
5029 if (PyErr_Occurred()) SWIG_fail;
5030 }
5031 Py_INCREF(Py_None); resultobj = Py_None;
5032 return resultobj;
5033 fail:
5034 return NULL;
5035 }
5036
5037
5038 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5039 PyObject *resultobj;
5040 wxRect *arg1 = (wxRect *) 0 ;
5041 int result;
5042 PyObject * obj0 = 0 ;
5043 char *kwnames[] = {
5044 (char *) "self", NULL
5045 };
5046
5047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5049 if (SWIG_arg_fail(1)) SWIG_fail;
5050 {
5051 PyThreadState* __tstate = wxPyBeginAllowThreads();
5052 result = (int)((wxRect const *)arg1)->GetWidth();
5053
5054 wxPyEndAllowThreads(__tstate);
5055 if (PyErr_Occurred()) SWIG_fail;
5056 }
5057 {
5058 resultobj = SWIG_From_int((int)(result));
5059 }
5060 return resultobj;
5061 fail:
5062 return NULL;
5063 }
5064
5065
5066 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5067 PyObject *resultobj;
5068 wxRect *arg1 = (wxRect *) 0 ;
5069 int arg2 ;
5070 PyObject * obj0 = 0 ;
5071 PyObject * obj1 = 0 ;
5072 char *kwnames[] = {
5073 (char *) "self",(char *) "w", NULL
5074 };
5075
5076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5078 if (SWIG_arg_fail(1)) SWIG_fail;
5079 {
5080 arg2 = (int)(SWIG_As_int(obj1));
5081 if (SWIG_arg_fail(2)) SWIG_fail;
5082 }
5083 {
5084 PyThreadState* __tstate = wxPyBeginAllowThreads();
5085 (arg1)->SetWidth(arg2);
5086
5087 wxPyEndAllowThreads(__tstate);
5088 if (PyErr_Occurred()) SWIG_fail;
5089 }
5090 Py_INCREF(Py_None); resultobj = Py_None;
5091 return resultobj;
5092 fail:
5093 return NULL;
5094 }
5095
5096
5097 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5098 PyObject *resultobj;
5099 wxRect *arg1 = (wxRect *) 0 ;
5100 int result;
5101 PyObject * obj0 = 0 ;
5102 char *kwnames[] = {
5103 (char *) "self", NULL
5104 };
5105
5106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5108 if (SWIG_arg_fail(1)) SWIG_fail;
5109 {
5110 PyThreadState* __tstate = wxPyBeginAllowThreads();
5111 result = (int)((wxRect const *)arg1)->GetHeight();
5112
5113 wxPyEndAllowThreads(__tstate);
5114 if (PyErr_Occurred()) SWIG_fail;
5115 }
5116 {
5117 resultobj = SWIG_From_int((int)(result));
5118 }
5119 return resultobj;
5120 fail:
5121 return NULL;
5122 }
5123
5124
5125 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5126 PyObject *resultobj;
5127 wxRect *arg1 = (wxRect *) 0 ;
5128 int arg2 ;
5129 PyObject * obj0 = 0 ;
5130 PyObject * obj1 = 0 ;
5131 char *kwnames[] = {
5132 (char *) "self",(char *) "h", NULL
5133 };
5134
5135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5137 if (SWIG_arg_fail(1)) SWIG_fail;
5138 {
5139 arg2 = (int)(SWIG_As_int(obj1));
5140 if (SWIG_arg_fail(2)) SWIG_fail;
5141 }
5142 {
5143 PyThreadState* __tstate = wxPyBeginAllowThreads();
5144 (arg1)->SetHeight(arg2);
5145
5146 wxPyEndAllowThreads(__tstate);
5147 if (PyErr_Occurred()) SWIG_fail;
5148 }
5149 Py_INCREF(Py_None); resultobj = Py_None;
5150 return resultobj;
5151 fail:
5152 return NULL;
5153 }
5154
5155
5156 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5157 PyObject *resultobj;
5158 wxRect *arg1 = (wxRect *) 0 ;
5159 wxPoint result;
5160 PyObject * obj0 = 0 ;
5161 char *kwnames[] = {
5162 (char *) "self", NULL
5163 };
5164
5165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5167 if (SWIG_arg_fail(1)) SWIG_fail;
5168 {
5169 PyThreadState* __tstate = wxPyBeginAllowThreads();
5170 result = ((wxRect const *)arg1)->GetPosition();
5171
5172 wxPyEndAllowThreads(__tstate);
5173 if (PyErr_Occurred()) SWIG_fail;
5174 }
5175 {
5176 wxPoint * resultptr;
5177 resultptr = new wxPoint((wxPoint &)(result));
5178 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5179 }
5180 return resultobj;
5181 fail:
5182 return NULL;
5183 }
5184
5185
5186 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5187 PyObject *resultobj;
5188 wxRect *arg1 = (wxRect *) 0 ;
5189 wxPoint *arg2 = 0 ;
5190 wxPoint temp2 ;
5191 PyObject * obj0 = 0 ;
5192 PyObject * obj1 = 0 ;
5193 char *kwnames[] = {
5194 (char *) "self",(char *) "p", NULL
5195 };
5196
5197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5199 if (SWIG_arg_fail(1)) SWIG_fail;
5200 {
5201 arg2 = &temp2;
5202 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5203 }
5204 {
5205 PyThreadState* __tstate = wxPyBeginAllowThreads();
5206 (arg1)->SetPosition((wxPoint const &)*arg2);
5207
5208 wxPyEndAllowThreads(__tstate);
5209 if (PyErr_Occurred()) SWIG_fail;
5210 }
5211 Py_INCREF(Py_None); resultobj = Py_None;
5212 return resultobj;
5213 fail:
5214 return NULL;
5215 }
5216
5217
5218 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5219 PyObject *resultobj;
5220 wxRect *arg1 = (wxRect *) 0 ;
5221 wxSize result;
5222 PyObject * obj0 = 0 ;
5223 char *kwnames[] = {
5224 (char *) "self", NULL
5225 };
5226
5227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5229 if (SWIG_arg_fail(1)) SWIG_fail;
5230 {
5231 PyThreadState* __tstate = wxPyBeginAllowThreads();
5232 result = ((wxRect const *)arg1)->GetSize();
5233
5234 wxPyEndAllowThreads(__tstate);
5235 if (PyErr_Occurred()) SWIG_fail;
5236 }
5237 {
5238 wxSize * resultptr;
5239 resultptr = new wxSize((wxSize &)(result));
5240 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5241 }
5242 return resultobj;
5243 fail:
5244 return NULL;
5245 }
5246
5247
5248 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5249 PyObject *resultobj;
5250 wxRect *arg1 = (wxRect *) 0 ;
5251 wxSize *arg2 = 0 ;
5252 wxSize temp2 ;
5253 PyObject * obj0 = 0 ;
5254 PyObject * obj1 = 0 ;
5255 char *kwnames[] = {
5256 (char *) "self",(char *) "s", NULL
5257 };
5258
5259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5261 if (SWIG_arg_fail(1)) SWIG_fail;
5262 {
5263 arg2 = &temp2;
5264 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5265 }
5266 {
5267 PyThreadState* __tstate = wxPyBeginAllowThreads();
5268 (arg1)->SetSize((wxSize const &)*arg2);
5269
5270 wxPyEndAllowThreads(__tstate);
5271 if (PyErr_Occurred()) SWIG_fail;
5272 }
5273 Py_INCREF(Py_None); resultobj = Py_None;
5274 return resultobj;
5275 fail:
5276 return NULL;
5277 }
5278
5279
5280 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5281 PyObject *resultobj;
5282 wxRect *arg1 = (wxRect *) 0 ;
5283 wxPoint result;
5284 PyObject * obj0 = 0 ;
5285 char *kwnames[] = {
5286 (char *) "self", NULL
5287 };
5288
5289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5291 if (SWIG_arg_fail(1)) SWIG_fail;
5292 {
5293 PyThreadState* __tstate = wxPyBeginAllowThreads();
5294 result = ((wxRect const *)arg1)->GetTopLeft();
5295
5296 wxPyEndAllowThreads(__tstate);
5297 if (PyErr_Occurred()) SWIG_fail;
5298 }
5299 {
5300 wxPoint * resultptr;
5301 resultptr = new wxPoint((wxPoint &)(result));
5302 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5303 }
5304 return resultobj;
5305 fail:
5306 return NULL;
5307 }
5308
5309
5310 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5311 PyObject *resultobj;
5312 wxRect *arg1 = (wxRect *) 0 ;
5313 wxPoint *arg2 = 0 ;
5314 wxPoint temp2 ;
5315 PyObject * obj0 = 0 ;
5316 PyObject * obj1 = 0 ;
5317 char *kwnames[] = {
5318 (char *) "self",(char *) "p", NULL
5319 };
5320
5321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5323 if (SWIG_arg_fail(1)) SWIG_fail;
5324 {
5325 arg2 = &temp2;
5326 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5327 }
5328 {
5329 PyThreadState* __tstate = wxPyBeginAllowThreads();
5330 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5331
5332 wxPyEndAllowThreads(__tstate);
5333 if (PyErr_Occurred()) SWIG_fail;
5334 }
5335 Py_INCREF(Py_None); resultobj = Py_None;
5336 return resultobj;
5337 fail:
5338 return NULL;
5339 }
5340
5341
5342 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5343 PyObject *resultobj;
5344 wxRect *arg1 = (wxRect *) 0 ;
5345 wxPoint result;
5346 PyObject * obj0 = 0 ;
5347 char *kwnames[] = {
5348 (char *) "self", NULL
5349 };
5350
5351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5353 if (SWIG_arg_fail(1)) SWIG_fail;
5354 {
5355 PyThreadState* __tstate = wxPyBeginAllowThreads();
5356 result = ((wxRect const *)arg1)->GetBottomRight();
5357
5358 wxPyEndAllowThreads(__tstate);
5359 if (PyErr_Occurred()) SWIG_fail;
5360 }
5361 {
5362 wxPoint * resultptr;
5363 resultptr = new wxPoint((wxPoint &)(result));
5364 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5365 }
5366 return resultobj;
5367 fail:
5368 return NULL;
5369 }
5370
5371
5372 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5373 PyObject *resultobj;
5374 wxRect *arg1 = (wxRect *) 0 ;
5375 wxPoint *arg2 = 0 ;
5376 wxPoint temp2 ;
5377 PyObject * obj0 = 0 ;
5378 PyObject * obj1 = 0 ;
5379 char *kwnames[] = {
5380 (char *) "self",(char *) "p", NULL
5381 };
5382
5383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5385 if (SWIG_arg_fail(1)) SWIG_fail;
5386 {
5387 arg2 = &temp2;
5388 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5389 }
5390 {
5391 PyThreadState* __tstate = wxPyBeginAllowThreads();
5392 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5393
5394 wxPyEndAllowThreads(__tstate);
5395 if (PyErr_Occurred()) SWIG_fail;
5396 }
5397 Py_INCREF(Py_None); resultobj = Py_None;
5398 return resultobj;
5399 fail:
5400 return NULL;
5401 }
5402
5403
5404 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5405 PyObject *resultobj;
5406 wxRect *arg1 = (wxRect *) 0 ;
5407 int result;
5408 PyObject * obj0 = 0 ;
5409 char *kwnames[] = {
5410 (char *) "self", NULL
5411 };
5412
5413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5415 if (SWIG_arg_fail(1)) SWIG_fail;
5416 {
5417 PyThreadState* __tstate = wxPyBeginAllowThreads();
5418 result = (int)((wxRect const *)arg1)->GetLeft();
5419
5420 wxPyEndAllowThreads(__tstate);
5421 if (PyErr_Occurred()) SWIG_fail;
5422 }
5423 {
5424 resultobj = SWIG_From_int((int)(result));
5425 }
5426 return resultobj;
5427 fail:
5428 return NULL;
5429 }
5430
5431
5432 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5433 PyObject *resultobj;
5434 wxRect *arg1 = (wxRect *) 0 ;
5435 int result;
5436 PyObject * obj0 = 0 ;
5437 char *kwnames[] = {
5438 (char *) "self", NULL
5439 };
5440
5441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5443 if (SWIG_arg_fail(1)) SWIG_fail;
5444 {
5445 PyThreadState* __tstate = wxPyBeginAllowThreads();
5446 result = (int)((wxRect const *)arg1)->GetTop();
5447
5448 wxPyEndAllowThreads(__tstate);
5449 if (PyErr_Occurred()) SWIG_fail;
5450 }
5451 {
5452 resultobj = SWIG_From_int((int)(result));
5453 }
5454 return resultobj;
5455 fail:
5456 return NULL;
5457 }
5458
5459
5460 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5461 PyObject *resultobj;
5462 wxRect *arg1 = (wxRect *) 0 ;
5463 int result;
5464 PyObject * obj0 = 0 ;
5465 char *kwnames[] = {
5466 (char *) "self", NULL
5467 };
5468
5469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5471 if (SWIG_arg_fail(1)) SWIG_fail;
5472 {
5473 PyThreadState* __tstate = wxPyBeginAllowThreads();
5474 result = (int)((wxRect const *)arg1)->GetBottom();
5475
5476 wxPyEndAllowThreads(__tstate);
5477 if (PyErr_Occurred()) SWIG_fail;
5478 }
5479 {
5480 resultobj = SWIG_From_int((int)(result));
5481 }
5482 return resultobj;
5483 fail:
5484 return NULL;
5485 }
5486
5487
5488 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5489 PyObject *resultobj;
5490 wxRect *arg1 = (wxRect *) 0 ;
5491 int result;
5492 PyObject * obj0 = 0 ;
5493 char *kwnames[] = {
5494 (char *) "self", NULL
5495 };
5496
5497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5499 if (SWIG_arg_fail(1)) SWIG_fail;
5500 {
5501 PyThreadState* __tstate = wxPyBeginAllowThreads();
5502 result = (int)((wxRect const *)arg1)->GetRight();
5503
5504 wxPyEndAllowThreads(__tstate);
5505 if (PyErr_Occurred()) SWIG_fail;
5506 }
5507 {
5508 resultobj = SWIG_From_int((int)(result));
5509 }
5510 return resultobj;
5511 fail:
5512 return NULL;
5513 }
5514
5515
5516 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5517 PyObject *resultobj;
5518 wxRect *arg1 = (wxRect *) 0 ;
5519 int arg2 ;
5520 PyObject * obj0 = 0 ;
5521 PyObject * obj1 = 0 ;
5522 char *kwnames[] = {
5523 (char *) "self",(char *) "left", NULL
5524 };
5525
5526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5528 if (SWIG_arg_fail(1)) SWIG_fail;
5529 {
5530 arg2 = (int)(SWIG_As_int(obj1));
5531 if (SWIG_arg_fail(2)) SWIG_fail;
5532 }
5533 {
5534 PyThreadState* __tstate = wxPyBeginAllowThreads();
5535 (arg1)->SetLeft(arg2);
5536
5537 wxPyEndAllowThreads(__tstate);
5538 if (PyErr_Occurred()) SWIG_fail;
5539 }
5540 Py_INCREF(Py_None); resultobj = Py_None;
5541 return resultobj;
5542 fail:
5543 return NULL;
5544 }
5545
5546
5547 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5548 PyObject *resultobj;
5549 wxRect *arg1 = (wxRect *) 0 ;
5550 int arg2 ;
5551 PyObject * obj0 = 0 ;
5552 PyObject * obj1 = 0 ;
5553 char *kwnames[] = {
5554 (char *) "self",(char *) "right", NULL
5555 };
5556
5557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5559 if (SWIG_arg_fail(1)) SWIG_fail;
5560 {
5561 arg2 = (int)(SWIG_As_int(obj1));
5562 if (SWIG_arg_fail(2)) SWIG_fail;
5563 }
5564 {
5565 PyThreadState* __tstate = wxPyBeginAllowThreads();
5566 (arg1)->SetRight(arg2);
5567
5568 wxPyEndAllowThreads(__tstate);
5569 if (PyErr_Occurred()) SWIG_fail;
5570 }
5571 Py_INCREF(Py_None); resultobj = Py_None;
5572 return resultobj;
5573 fail:
5574 return NULL;
5575 }
5576
5577
5578 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5579 PyObject *resultobj;
5580 wxRect *arg1 = (wxRect *) 0 ;
5581 int arg2 ;
5582 PyObject * obj0 = 0 ;
5583 PyObject * obj1 = 0 ;
5584 char *kwnames[] = {
5585 (char *) "self",(char *) "top", NULL
5586 };
5587
5588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5590 if (SWIG_arg_fail(1)) SWIG_fail;
5591 {
5592 arg2 = (int)(SWIG_As_int(obj1));
5593 if (SWIG_arg_fail(2)) SWIG_fail;
5594 }
5595 {
5596 PyThreadState* __tstate = wxPyBeginAllowThreads();
5597 (arg1)->SetTop(arg2);
5598
5599 wxPyEndAllowThreads(__tstate);
5600 if (PyErr_Occurred()) SWIG_fail;
5601 }
5602 Py_INCREF(Py_None); resultobj = Py_None;
5603 return resultobj;
5604 fail:
5605 return NULL;
5606 }
5607
5608
5609 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5610 PyObject *resultobj;
5611 wxRect *arg1 = (wxRect *) 0 ;
5612 int arg2 ;
5613 PyObject * obj0 = 0 ;
5614 PyObject * obj1 = 0 ;
5615 char *kwnames[] = {
5616 (char *) "self",(char *) "bottom", NULL
5617 };
5618
5619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5621 if (SWIG_arg_fail(1)) SWIG_fail;
5622 {
5623 arg2 = (int)(SWIG_As_int(obj1));
5624 if (SWIG_arg_fail(2)) SWIG_fail;
5625 }
5626 {
5627 PyThreadState* __tstate = wxPyBeginAllowThreads();
5628 (arg1)->SetBottom(arg2);
5629
5630 wxPyEndAllowThreads(__tstate);
5631 if (PyErr_Occurred()) SWIG_fail;
5632 }
5633 Py_INCREF(Py_None); resultobj = Py_None;
5634 return resultobj;
5635 fail:
5636 return NULL;
5637 }
5638
5639
5640 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5641 PyObject *resultobj;
5642 wxRect *arg1 = (wxRect *) 0 ;
5643 int arg2 ;
5644 int arg3 ;
5645 wxRect *result;
5646 PyObject * obj0 = 0 ;
5647 PyObject * obj1 = 0 ;
5648 PyObject * obj2 = 0 ;
5649 char *kwnames[] = {
5650 (char *) "self",(char *) "dx",(char *) "dy", NULL
5651 };
5652
5653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5655 if (SWIG_arg_fail(1)) SWIG_fail;
5656 {
5657 arg2 = (int)(SWIG_As_int(obj1));
5658 if (SWIG_arg_fail(2)) SWIG_fail;
5659 }
5660 {
5661 arg3 = (int)(SWIG_As_int(obj2));
5662 if (SWIG_arg_fail(3)) SWIG_fail;
5663 }
5664 {
5665 PyThreadState* __tstate = wxPyBeginAllowThreads();
5666 {
5667 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5668 result = (wxRect *) &_result_ref;
5669 }
5670
5671 wxPyEndAllowThreads(__tstate);
5672 if (PyErr_Occurred()) SWIG_fail;
5673 }
5674 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5675 return resultobj;
5676 fail:
5677 return NULL;
5678 }
5679
5680
5681 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5682 PyObject *resultobj;
5683 wxRect *arg1 = (wxRect *) 0 ;
5684 int arg2 ;
5685 int arg3 ;
5686 wxRect *result;
5687 PyObject * obj0 = 0 ;
5688 PyObject * obj1 = 0 ;
5689 PyObject * obj2 = 0 ;
5690 char *kwnames[] = {
5691 (char *) "self",(char *) "dx",(char *) "dy", NULL
5692 };
5693
5694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5696 if (SWIG_arg_fail(1)) SWIG_fail;
5697 {
5698 arg2 = (int)(SWIG_As_int(obj1));
5699 if (SWIG_arg_fail(2)) SWIG_fail;
5700 }
5701 {
5702 arg3 = (int)(SWIG_As_int(obj2));
5703 if (SWIG_arg_fail(3)) SWIG_fail;
5704 }
5705 {
5706 PyThreadState* __tstate = wxPyBeginAllowThreads();
5707 {
5708 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5709 result = (wxRect *) &_result_ref;
5710 }
5711
5712 wxPyEndAllowThreads(__tstate);
5713 if (PyErr_Occurred()) SWIG_fail;
5714 }
5715 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5716 return resultobj;
5717 fail:
5718 return NULL;
5719 }
5720
5721
5722 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5723 PyObject *resultobj;
5724 wxRect *arg1 = (wxRect *) 0 ;
5725 int arg2 ;
5726 int arg3 ;
5727 PyObject * obj0 = 0 ;
5728 PyObject * obj1 = 0 ;
5729 PyObject * obj2 = 0 ;
5730 char *kwnames[] = {
5731 (char *) "self",(char *) "dx",(char *) "dy", NULL
5732 };
5733
5734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5736 if (SWIG_arg_fail(1)) SWIG_fail;
5737 {
5738 arg2 = (int)(SWIG_As_int(obj1));
5739 if (SWIG_arg_fail(2)) SWIG_fail;
5740 }
5741 {
5742 arg3 = (int)(SWIG_As_int(obj2));
5743 if (SWIG_arg_fail(3)) SWIG_fail;
5744 }
5745 {
5746 PyThreadState* __tstate = wxPyBeginAllowThreads();
5747 (arg1)->Offset(arg2,arg3);
5748
5749 wxPyEndAllowThreads(__tstate);
5750 if (PyErr_Occurred()) SWIG_fail;
5751 }
5752 Py_INCREF(Py_None); resultobj = Py_None;
5753 return resultobj;
5754 fail:
5755 return NULL;
5756 }
5757
5758
5759 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5760 PyObject *resultobj;
5761 wxRect *arg1 = (wxRect *) 0 ;
5762 wxPoint *arg2 = 0 ;
5763 wxPoint temp2 ;
5764 PyObject * obj0 = 0 ;
5765 PyObject * obj1 = 0 ;
5766 char *kwnames[] = {
5767 (char *) "self",(char *) "pt", NULL
5768 };
5769
5770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5772 if (SWIG_arg_fail(1)) SWIG_fail;
5773 {
5774 arg2 = &temp2;
5775 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5776 }
5777 {
5778 PyThreadState* __tstate = wxPyBeginAllowThreads();
5779 (arg1)->Offset((wxPoint const &)*arg2);
5780
5781 wxPyEndAllowThreads(__tstate);
5782 if (PyErr_Occurred()) SWIG_fail;
5783 }
5784 Py_INCREF(Py_None); resultobj = Py_None;
5785 return resultobj;
5786 fail:
5787 return NULL;
5788 }
5789
5790
5791 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5792 PyObject *resultobj;
5793 wxRect *arg1 = (wxRect *) 0 ;
5794 wxRect *arg2 = 0 ;
5795 wxRect result;
5796 wxRect temp2 ;
5797 PyObject * obj0 = 0 ;
5798 PyObject * obj1 = 0 ;
5799 char *kwnames[] = {
5800 (char *) "self",(char *) "rect", NULL
5801 };
5802
5803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5805 if (SWIG_arg_fail(1)) SWIG_fail;
5806 {
5807 arg2 = &temp2;
5808 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5809 }
5810 {
5811 PyThreadState* __tstate = wxPyBeginAllowThreads();
5812 result = (arg1)->Intersect((wxRect const &)*arg2);
5813
5814 wxPyEndAllowThreads(__tstate);
5815 if (PyErr_Occurred()) SWIG_fail;
5816 }
5817 {
5818 wxRect * resultptr;
5819 resultptr = new wxRect((wxRect &)(result));
5820 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5821 }
5822 return resultobj;
5823 fail:
5824 return NULL;
5825 }
5826
5827
5828 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5829 PyObject *resultobj;
5830 wxRect *arg1 = (wxRect *) 0 ;
5831 wxRect *arg2 = 0 ;
5832 wxRect result;
5833 wxRect temp2 ;
5834 PyObject * obj0 = 0 ;
5835 PyObject * obj1 = 0 ;
5836 char *kwnames[] = {
5837 (char *) "self",(char *) "rect", NULL
5838 };
5839
5840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5842 if (SWIG_arg_fail(1)) SWIG_fail;
5843 {
5844 arg2 = &temp2;
5845 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5846 }
5847 {
5848 PyThreadState* __tstate = wxPyBeginAllowThreads();
5849 result = (arg1)->Union((wxRect const &)*arg2);
5850
5851 wxPyEndAllowThreads(__tstate);
5852 if (PyErr_Occurred()) SWIG_fail;
5853 }
5854 {
5855 wxRect * resultptr;
5856 resultptr = new wxRect((wxRect &)(result));
5857 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5858 }
5859 return resultobj;
5860 fail:
5861 return NULL;
5862 }
5863
5864
5865 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5866 PyObject *resultobj;
5867 wxRect *arg1 = (wxRect *) 0 ;
5868 wxRect *arg2 = 0 ;
5869 wxRect result;
5870 wxRect temp2 ;
5871 PyObject * obj0 = 0 ;
5872 PyObject * obj1 = 0 ;
5873 char *kwnames[] = {
5874 (char *) "self",(char *) "rect", NULL
5875 };
5876
5877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5879 if (SWIG_arg_fail(1)) SWIG_fail;
5880 {
5881 arg2 = &temp2;
5882 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5883 }
5884 {
5885 PyThreadState* __tstate = wxPyBeginAllowThreads();
5886 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5887
5888 wxPyEndAllowThreads(__tstate);
5889 if (PyErr_Occurred()) SWIG_fail;
5890 }
5891 {
5892 wxRect * resultptr;
5893 resultptr = new wxRect((wxRect &)(result));
5894 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5895 }
5896 return resultobj;
5897 fail:
5898 return NULL;
5899 }
5900
5901
5902 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5903 PyObject *resultobj;
5904 wxRect *arg1 = (wxRect *) 0 ;
5905 wxRect *arg2 = 0 ;
5906 wxRect *result;
5907 wxRect temp2 ;
5908 PyObject * obj0 = 0 ;
5909 PyObject * obj1 = 0 ;
5910 char *kwnames[] = {
5911 (char *) "self",(char *) "rect", NULL
5912 };
5913
5914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5916 if (SWIG_arg_fail(1)) SWIG_fail;
5917 {
5918 arg2 = &temp2;
5919 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5920 }
5921 {
5922 PyThreadState* __tstate = wxPyBeginAllowThreads();
5923 {
5924 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5925 result = (wxRect *) &_result_ref;
5926 }
5927
5928 wxPyEndAllowThreads(__tstate);
5929 if (PyErr_Occurred()) SWIG_fail;
5930 }
5931 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5932 return resultobj;
5933 fail:
5934 return NULL;
5935 }
5936
5937
5938 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5939 PyObject *resultobj;
5940 wxRect *arg1 = (wxRect *) 0 ;
5941 wxRect *arg2 = 0 ;
5942 bool result;
5943 wxRect temp2 ;
5944 PyObject * obj0 = 0 ;
5945 PyObject * obj1 = 0 ;
5946 char *kwnames[] = {
5947 (char *) "self",(char *) "rect", NULL
5948 };
5949
5950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5952 if (SWIG_arg_fail(1)) SWIG_fail;
5953 {
5954 arg2 = &temp2;
5955 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5956 }
5957 {
5958 PyThreadState* __tstate = wxPyBeginAllowThreads();
5959 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5960
5961 wxPyEndAllowThreads(__tstate);
5962 if (PyErr_Occurred()) SWIG_fail;
5963 }
5964 {
5965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5966 }
5967 return resultobj;
5968 fail:
5969 return NULL;
5970 }
5971
5972
5973 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5974 PyObject *resultobj;
5975 wxRect *arg1 = (wxRect *) 0 ;
5976 wxRect *arg2 = 0 ;
5977 bool result;
5978 wxRect temp2 ;
5979 PyObject * obj0 = 0 ;
5980 PyObject * obj1 = 0 ;
5981 char *kwnames[] = {
5982 (char *) "self",(char *) "rect", NULL
5983 };
5984
5985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
5986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5987 if (SWIG_arg_fail(1)) SWIG_fail;
5988 {
5989 arg2 = &temp2;
5990 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5991 }
5992 {
5993 PyThreadState* __tstate = wxPyBeginAllowThreads();
5994 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
5995
5996 wxPyEndAllowThreads(__tstate);
5997 if (PyErr_Occurred()) SWIG_fail;
5998 }
5999 {
6000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6001 }
6002 return resultobj;
6003 fail:
6004 return NULL;
6005 }
6006
6007
6008 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6009 PyObject *resultobj;
6010 wxRect *arg1 = (wxRect *) 0 ;
6011 int arg2 ;
6012 int arg3 ;
6013 bool result;
6014 PyObject * obj0 = 0 ;
6015 PyObject * obj1 = 0 ;
6016 PyObject * obj2 = 0 ;
6017 char *kwnames[] = {
6018 (char *) "self",(char *) "x",(char *) "y", NULL
6019 };
6020
6021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6023 if (SWIG_arg_fail(1)) SWIG_fail;
6024 {
6025 arg2 = (int)(SWIG_As_int(obj1));
6026 if (SWIG_arg_fail(2)) SWIG_fail;
6027 }
6028 {
6029 arg3 = (int)(SWIG_As_int(obj2));
6030 if (SWIG_arg_fail(3)) SWIG_fail;
6031 }
6032 {
6033 PyThreadState* __tstate = wxPyBeginAllowThreads();
6034 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6035
6036 wxPyEndAllowThreads(__tstate);
6037 if (PyErr_Occurred()) SWIG_fail;
6038 }
6039 {
6040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6041 }
6042 return resultobj;
6043 fail:
6044 return NULL;
6045 }
6046
6047
6048 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6049 PyObject *resultobj;
6050 wxRect *arg1 = (wxRect *) 0 ;
6051 wxPoint *arg2 = 0 ;
6052 bool result;
6053 wxPoint temp2 ;
6054 PyObject * obj0 = 0 ;
6055 PyObject * obj1 = 0 ;
6056 char *kwnames[] = {
6057 (char *) "self",(char *) "pt", NULL
6058 };
6059
6060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6062 if (SWIG_arg_fail(1)) SWIG_fail;
6063 {
6064 arg2 = &temp2;
6065 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6066 }
6067 {
6068 PyThreadState* __tstate = wxPyBeginAllowThreads();
6069 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6070
6071 wxPyEndAllowThreads(__tstate);
6072 if (PyErr_Occurred()) SWIG_fail;
6073 }
6074 {
6075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6076 }
6077 return resultobj;
6078 fail:
6079 return NULL;
6080 }
6081
6082
6083 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6084 PyObject *resultobj;
6085 wxRect *arg1 = (wxRect *) 0 ;
6086 wxRect *arg2 = 0 ;
6087 bool result;
6088 wxRect temp2 ;
6089 PyObject * obj0 = 0 ;
6090 PyObject * obj1 = 0 ;
6091 char *kwnames[] = {
6092 (char *) "self",(char *) "rect", NULL
6093 };
6094
6095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6097 if (SWIG_arg_fail(1)) SWIG_fail;
6098 {
6099 arg2 = &temp2;
6100 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6101 }
6102 {
6103 PyThreadState* __tstate = wxPyBeginAllowThreads();
6104 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6105
6106 wxPyEndAllowThreads(__tstate);
6107 if (PyErr_Occurred()) SWIG_fail;
6108 }
6109 {
6110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6111 }
6112 return resultobj;
6113 fail:
6114 return NULL;
6115 }
6116
6117
6118 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6119 PyObject *resultobj;
6120 wxRect *arg1 = (wxRect *) 0 ;
6121 int arg2 ;
6122 PyObject * obj0 = 0 ;
6123 PyObject * obj1 = 0 ;
6124 char *kwnames[] = {
6125 (char *) "self",(char *) "x", NULL
6126 };
6127
6128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6130 if (SWIG_arg_fail(1)) SWIG_fail;
6131 {
6132 arg2 = (int)(SWIG_As_int(obj1));
6133 if (SWIG_arg_fail(2)) SWIG_fail;
6134 }
6135 if (arg1) (arg1)->x = arg2;
6136
6137 Py_INCREF(Py_None); resultobj = Py_None;
6138 return resultobj;
6139 fail:
6140 return NULL;
6141 }
6142
6143
6144 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6145 PyObject *resultobj;
6146 wxRect *arg1 = (wxRect *) 0 ;
6147 int result;
6148 PyObject * obj0 = 0 ;
6149 char *kwnames[] = {
6150 (char *) "self", NULL
6151 };
6152
6153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6155 if (SWIG_arg_fail(1)) SWIG_fail;
6156 result = (int) ((arg1)->x);
6157
6158 {
6159 resultobj = SWIG_From_int((int)(result));
6160 }
6161 return resultobj;
6162 fail:
6163 return NULL;
6164 }
6165
6166
6167 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6168 PyObject *resultobj;
6169 wxRect *arg1 = (wxRect *) 0 ;
6170 int arg2 ;
6171 PyObject * obj0 = 0 ;
6172 PyObject * obj1 = 0 ;
6173 char *kwnames[] = {
6174 (char *) "self",(char *) "y", NULL
6175 };
6176
6177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6179 if (SWIG_arg_fail(1)) SWIG_fail;
6180 {
6181 arg2 = (int)(SWIG_As_int(obj1));
6182 if (SWIG_arg_fail(2)) SWIG_fail;
6183 }
6184 if (arg1) (arg1)->y = arg2;
6185
6186 Py_INCREF(Py_None); resultobj = Py_None;
6187 return resultobj;
6188 fail:
6189 return NULL;
6190 }
6191
6192
6193 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6194 PyObject *resultobj;
6195 wxRect *arg1 = (wxRect *) 0 ;
6196 int result;
6197 PyObject * obj0 = 0 ;
6198 char *kwnames[] = {
6199 (char *) "self", NULL
6200 };
6201
6202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6204 if (SWIG_arg_fail(1)) SWIG_fail;
6205 result = (int) ((arg1)->y);
6206
6207 {
6208 resultobj = SWIG_From_int((int)(result));
6209 }
6210 return resultobj;
6211 fail:
6212 return NULL;
6213 }
6214
6215
6216 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6217 PyObject *resultobj;
6218 wxRect *arg1 = (wxRect *) 0 ;
6219 int arg2 ;
6220 PyObject * obj0 = 0 ;
6221 PyObject * obj1 = 0 ;
6222 char *kwnames[] = {
6223 (char *) "self",(char *) "width", NULL
6224 };
6225
6226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6228 if (SWIG_arg_fail(1)) SWIG_fail;
6229 {
6230 arg2 = (int)(SWIG_As_int(obj1));
6231 if (SWIG_arg_fail(2)) SWIG_fail;
6232 }
6233 if (arg1) (arg1)->width = arg2;
6234
6235 Py_INCREF(Py_None); resultobj = Py_None;
6236 return resultobj;
6237 fail:
6238 return NULL;
6239 }
6240
6241
6242 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6243 PyObject *resultobj;
6244 wxRect *arg1 = (wxRect *) 0 ;
6245 int result;
6246 PyObject * obj0 = 0 ;
6247 char *kwnames[] = {
6248 (char *) "self", NULL
6249 };
6250
6251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6253 if (SWIG_arg_fail(1)) SWIG_fail;
6254 result = (int) ((arg1)->width);
6255
6256 {
6257 resultobj = SWIG_From_int((int)(result));
6258 }
6259 return resultobj;
6260 fail:
6261 return NULL;
6262 }
6263
6264
6265 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6266 PyObject *resultobj;
6267 wxRect *arg1 = (wxRect *) 0 ;
6268 int arg2 ;
6269 PyObject * obj0 = 0 ;
6270 PyObject * obj1 = 0 ;
6271 char *kwnames[] = {
6272 (char *) "self",(char *) "height", NULL
6273 };
6274
6275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6277 if (SWIG_arg_fail(1)) SWIG_fail;
6278 {
6279 arg2 = (int)(SWIG_As_int(obj1));
6280 if (SWIG_arg_fail(2)) SWIG_fail;
6281 }
6282 if (arg1) (arg1)->height = arg2;
6283
6284 Py_INCREF(Py_None); resultobj = Py_None;
6285 return resultobj;
6286 fail:
6287 return NULL;
6288 }
6289
6290
6291 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6292 PyObject *resultobj;
6293 wxRect *arg1 = (wxRect *) 0 ;
6294 int result;
6295 PyObject * obj0 = 0 ;
6296 char *kwnames[] = {
6297 (char *) "self", NULL
6298 };
6299
6300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6302 if (SWIG_arg_fail(1)) SWIG_fail;
6303 result = (int) ((arg1)->height);
6304
6305 {
6306 resultobj = SWIG_From_int((int)(result));
6307 }
6308 return resultobj;
6309 fail:
6310 return NULL;
6311 }
6312
6313
6314 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6315 PyObject *resultobj;
6316 wxRect *arg1 = (wxRect *) 0 ;
6317 int arg2 = (int) 0 ;
6318 int arg3 = (int) 0 ;
6319 int arg4 = (int) 0 ;
6320 int arg5 = (int) 0 ;
6321 PyObject * obj0 = 0 ;
6322 PyObject * obj1 = 0 ;
6323 PyObject * obj2 = 0 ;
6324 PyObject * obj3 = 0 ;
6325 PyObject * obj4 = 0 ;
6326 char *kwnames[] = {
6327 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6328 };
6329
6330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6332 if (SWIG_arg_fail(1)) SWIG_fail;
6333 if (obj1) {
6334 {
6335 arg2 = (int)(SWIG_As_int(obj1));
6336 if (SWIG_arg_fail(2)) SWIG_fail;
6337 }
6338 }
6339 if (obj2) {
6340 {
6341 arg3 = (int)(SWIG_As_int(obj2));
6342 if (SWIG_arg_fail(3)) SWIG_fail;
6343 }
6344 }
6345 if (obj3) {
6346 {
6347 arg4 = (int)(SWIG_As_int(obj3));
6348 if (SWIG_arg_fail(4)) SWIG_fail;
6349 }
6350 }
6351 if (obj4) {
6352 {
6353 arg5 = (int)(SWIG_As_int(obj4));
6354 if (SWIG_arg_fail(5)) SWIG_fail;
6355 }
6356 }
6357 {
6358 PyThreadState* __tstate = wxPyBeginAllowThreads();
6359 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6360
6361 wxPyEndAllowThreads(__tstate);
6362 if (PyErr_Occurred()) SWIG_fail;
6363 }
6364 Py_INCREF(Py_None); resultobj = Py_None;
6365 return resultobj;
6366 fail:
6367 return NULL;
6368 }
6369
6370
6371 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6372 PyObject *resultobj;
6373 wxRect *arg1 = (wxRect *) 0 ;
6374 PyObject *result;
6375 PyObject * obj0 = 0 ;
6376 char *kwnames[] = {
6377 (char *) "self", NULL
6378 };
6379
6380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6382 if (SWIG_arg_fail(1)) SWIG_fail;
6383 {
6384 PyThreadState* __tstate = wxPyBeginAllowThreads();
6385 result = (PyObject *)wxRect_Get(arg1);
6386
6387 wxPyEndAllowThreads(__tstate);
6388 if (PyErr_Occurred()) SWIG_fail;
6389 }
6390 resultobj = result;
6391 return resultobj;
6392 fail:
6393 return NULL;
6394 }
6395
6396
6397 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6398 PyObject *obj;
6399 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6400 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6401 Py_INCREF(obj);
6402 return Py_BuildValue((char *)"");
6403 }
6404 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6405 PyObject *resultobj;
6406 wxRect *arg1 = (wxRect *) 0 ;
6407 wxRect *arg2 = (wxRect *) 0 ;
6408 PyObject *result;
6409 PyObject * obj0 = 0 ;
6410 PyObject * obj1 = 0 ;
6411 char *kwnames[] = {
6412 (char *) "r1",(char *) "r2", NULL
6413 };
6414
6415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6417 if (SWIG_arg_fail(1)) SWIG_fail;
6418 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6419 if (SWIG_arg_fail(2)) SWIG_fail;
6420 {
6421 if (!wxPyCheckForApp()) SWIG_fail;
6422 PyThreadState* __tstate = wxPyBeginAllowThreads();
6423 result = (PyObject *)wxIntersectRect(arg1,arg2);
6424
6425 wxPyEndAllowThreads(__tstate);
6426 if (PyErr_Occurred()) SWIG_fail;
6427 }
6428 resultobj = result;
6429 return resultobj;
6430 fail:
6431 return NULL;
6432 }
6433
6434
6435 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6436 PyObject *resultobj;
6437 double arg1 = (double) 0.0 ;
6438 double arg2 = (double) 0.0 ;
6439 wxPoint2D *result;
6440 PyObject * obj0 = 0 ;
6441 PyObject * obj1 = 0 ;
6442 char *kwnames[] = {
6443 (char *) "x",(char *) "y", NULL
6444 };
6445
6446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6447 if (obj0) {
6448 {
6449 arg1 = (double)(SWIG_As_double(obj0));
6450 if (SWIG_arg_fail(1)) SWIG_fail;
6451 }
6452 }
6453 if (obj1) {
6454 {
6455 arg2 = (double)(SWIG_As_double(obj1));
6456 if (SWIG_arg_fail(2)) SWIG_fail;
6457 }
6458 }
6459 {
6460 PyThreadState* __tstate = wxPyBeginAllowThreads();
6461 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6462
6463 wxPyEndAllowThreads(__tstate);
6464 if (PyErr_Occurred()) SWIG_fail;
6465 }
6466 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6467 return resultobj;
6468 fail:
6469 return NULL;
6470 }
6471
6472
6473 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6474 PyObject *resultobj;
6475 wxPoint2D *arg1 = 0 ;
6476 wxPoint2D *result;
6477 wxPoint2D temp1 ;
6478 PyObject * obj0 = 0 ;
6479 char *kwnames[] = {
6480 (char *) "pt", NULL
6481 };
6482
6483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6484 {
6485 arg1 = &temp1;
6486 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6487 }
6488 {
6489 PyThreadState* __tstate = wxPyBeginAllowThreads();
6490 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6491
6492 wxPyEndAllowThreads(__tstate);
6493 if (PyErr_Occurred()) SWIG_fail;
6494 }
6495 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6496 return resultobj;
6497 fail:
6498 return NULL;
6499 }
6500
6501
6502 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6503 PyObject *resultobj;
6504 wxPoint *arg1 = 0 ;
6505 wxPoint2D *result;
6506 wxPoint temp1 ;
6507 PyObject * obj0 = 0 ;
6508 char *kwnames[] = {
6509 (char *) "pt", NULL
6510 };
6511
6512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6513 {
6514 arg1 = &temp1;
6515 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6516 }
6517 {
6518 PyThreadState* __tstate = wxPyBeginAllowThreads();
6519 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6520
6521 wxPyEndAllowThreads(__tstate);
6522 if (PyErr_Occurred()) SWIG_fail;
6523 }
6524 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6525 return resultobj;
6526 fail:
6527 return NULL;
6528 }
6529
6530
6531 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6532 PyObject *resultobj;
6533 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6534 int *arg2 = (int *) 0 ;
6535 int *arg3 = (int *) 0 ;
6536 int temp2 ;
6537 int res2 = 0 ;
6538 int temp3 ;
6539 int res3 = 0 ;
6540 PyObject * obj0 = 0 ;
6541 char *kwnames[] = {
6542 (char *) "self", NULL
6543 };
6544
6545 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6546 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6549 if (SWIG_arg_fail(1)) SWIG_fail;
6550 {
6551 PyThreadState* __tstate = wxPyBeginAllowThreads();
6552 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6553
6554 wxPyEndAllowThreads(__tstate);
6555 if (PyErr_Occurred()) SWIG_fail;
6556 }
6557 Py_INCREF(Py_None); resultobj = Py_None;
6558 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6559 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6560 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6561 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6562 return resultobj;
6563 fail:
6564 return NULL;
6565 }
6566
6567
6568 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6569 PyObject *resultobj;
6570 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6571 int *arg2 = (int *) 0 ;
6572 int *arg3 = (int *) 0 ;
6573 int temp2 ;
6574 int res2 = 0 ;
6575 int temp3 ;
6576 int res3 = 0 ;
6577 PyObject * obj0 = 0 ;
6578 char *kwnames[] = {
6579 (char *) "self", NULL
6580 };
6581
6582 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6583 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6586 if (SWIG_arg_fail(1)) SWIG_fail;
6587 {
6588 PyThreadState* __tstate = wxPyBeginAllowThreads();
6589 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6590
6591 wxPyEndAllowThreads(__tstate);
6592 if (PyErr_Occurred()) SWIG_fail;
6593 }
6594 Py_INCREF(Py_None); resultobj = Py_None;
6595 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6596 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6597 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6598 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6599 return resultobj;
6600 fail:
6601 return NULL;
6602 }
6603
6604
6605 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6606 PyObject *resultobj;
6607 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6608 double result;
6609 PyObject * obj0 = 0 ;
6610 char *kwnames[] = {
6611 (char *) "self", NULL
6612 };
6613
6614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6616 if (SWIG_arg_fail(1)) SWIG_fail;
6617 {
6618 PyThreadState* __tstate = wxPyBeginAllowThreads();
6619 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6620
6621 wxPyEndAllowThreads(__tstate);
6622 if (PyErr_Occurred()) SWIG_fail;
6623 }
6624 {
6625 resultobj = SWIG_From_double((double)(result));
6626 }
6627 return resultobj;
6628 fail:
6629 return NULL;
6630 }
6631
6632
6633 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6634 PyObject *resultobj;
6635 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6636 double result;
6637 PyObject * obj0 = 0 ;
6638 char *kwnames[] = {
6639 (char *) "self", NULL
6640 };
6641
6642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6644 if (SWIG_arg_fail(1)) SWIG_fail;
6645 {
6646 PyThreadState* __tstate = wxPyBeginAllowThreads();
6647 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6648
6649 wxPyEndAllowThreads(__tstate);
6650 if (PyErr_Occurred()) SWIG_fail;
6651 }
6652 {
6653 resultobj = SWIG_From_double((double)(result));
6654 }
6655 return resultobj;
6656 fail:
6657 return NULL;
6658 }
6659
6660
6661 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6662 PyObject *resultobj;
6663 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6664 double arg2 ;
6665 PyObject * obj0 = 0 ;
6666 PyObject * obj1 = 0 ;
6667 char *kwnames[] = {
6668 (char *) "self",(char *) "length", NULL
6669 };
6670
6671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6673 if (SWIG_arg_fail(1)) SWIG_fail;
6674 {
6675 arg2 = (double)(SWIG_As_double(obj1));
6676 if (SWIG_arg_fail(2)) SWIG_fail;
6677 }
6678 {
6679 PyThreadState* __tstate = wxPyBeginAllowThreads();
6680 (arg1)->SetVectorLength(arg2);
6681
6682 wxPyEndAllowThreads(__tstate);
6683 if (PyErr_Occurred()) SWIG_fail;
6684 }
6685 Py_INCREF(Py_None); resultobj = Py_None;
6686 return resultobj;
6687 fail:
6688 return NULL;
6689 }
6690
6691
6692 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6693 PyObject *resultobj;
6694 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6695 double arg2 ;
6696 PyObject * obj0 = 0 ;
6697 PyObject * obj1 = 0 ;
6698 char *kwnames[] = {
6699 (char *) "self",(char *) "degrees", NULL
6700 };
6701
6702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6704 if (SWIG_arg_fail(1)) SWIG_fail;
6705 {
6706 arg2 = (double)(SWIG_As_double(obj1));
6707 if (SWIG_arg_fail(2)) SWIG_fail;
6708 }
6709 {
6710 PyThreadState* __tstate = wxPyBeginAllowThreads();
6711 (arg1)->SetVectorAngle(arg2);
6712
6713 wxPyEndAllowThreads(__tstate);
6714 if (PyErr_Occurred()) SWIG_fail;
6715 }
6716 Py_INCREF(Py_None); resultobj = Py_None;
6717 return resultobj;
6718 fail:
6719 return NULL;
6720 }
6721
6722
6723 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6724 PyObject *resultobj;
6725 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6726 wxPoint2D *arg2 = 0 ;
6727 double result;
6728 wxPoint2D temp2 ;
6729 PyObject * obj0 = 0 ;
6730 PyObject * obj1 = 0 ;
6731 char *kwnames[] = {
6732 (char *) "self",(char *) "pt", NULL
6733 };
6734
6735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6737 if (SWIG_arg_fail(1)) SWIG_fail;
6738 {
6739 arg2 = &temp2;
6740 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6741 }
6742 {
6743 PyThreadState* __tstate = wxPyBeginAllowThreads();
6744 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6745
6746 wxPyEndAllowThreads(__tstate);
6747 if (PyErr_Occurred()) SWIG_fail;
6748 }
6749 {
6750 resultobj = SWIG_From_double((double)(result));
6751 }
6752 return resultobj;
6753 fail:
6754 return NULL;
6755 }
6756
6757
6758 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6759 PyObject *resultobj;
6760 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6761 wxPoint2D *arg2 = 0 ;
6762 double result;
6763 wxPoint2D temp2 ;
6764 PyObject * obj0 = 0 ;
6765 PyObject * obj1 = 0 ;
6766 char *kwnames[] = {
6767 (char *) "self",(char *) "pt", NULL
6768 };
6769
6770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6772 if (SWIG_arg_fail(1)) SWIG_fail;
6773 {
6774 arg2 = &temp2;
6775 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6776 }
6777 {
6778 PyThreadState* __tstate = wxPyBeginAllowThreads();
6779 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6780
6781 wxPyEndAllowThreads(__tstate);
6782 if (PyErr_Occurred()) SWIG_fail;
6783 }
6784 {
6785 resultobj = SWIG_From_double((double)(result));
6786 }
6787 return resultobj;
6788 fail:
6789 return NULL;
6790 }
6791
6792
6793 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6794 PyObject *resultobj;
6795 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6796 wxPoint2D *arg2 = 0 ;
6797 double result;
6798 wxPoint2D temp2 ;
6799 PyObject * obj0 = 0 ;
6800 PyObject * obj1 = 0 ;
6801 char *kwnames[] = {
6802 (char *) "self",(char *) "vec", NULL
6803 };
6804
6805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6807 if (SWIG_arg_fail(1)) SWIG_fail;
6808 {
6809 arg2 = &temp2;
6810 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6811 }
6812 {
6813 PyThreadState* __tstate = wxPyBeginAllowThreads();
6814 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6815
6816 wxPyEndAllowThreads(__tstate);
6817 if (PyErr_Occurred()) SWIG_fail;
6818 }
6819 {
6820 resultobj = SWIG_From_double((double)(result));
6821 }
6822 return resultobj;
6823 fail:
6824 return NULL;
6825 }
6826
6827
6828 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6829 PyObject *resultobj;
6830 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6831 wxPoint2D *arg2 = 0 ;
6832 double result;
6833 wxPoint2D temp2 ;
6834 PyObject * obj0 = 0 ;
6835 PyObject * obj1 = 0 ;
6836 char *kwnames[] = {
6837 (char *) "self",(char *) "vec", NULL
6838 };
6839
6840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6842 if (SWIG_arg_fail(1)) SWIG_fail;
6843 {
6844 arg2 = &temp2;
6845 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6846 }
6847 {
6848 PyThreadState* __tstate = wxPyBeginAllowThreads();
6849 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6850
6851 wxPyEndAllowThreads(__tstate);
6852 if (PyErr_Occurred()) SWIG_fail;
6853 }
6854 {
6855 resultobj = SWIG_From_double((double)(result));
6856 }
6857 return resultobj;
6858 fail:
6859 return NULL;
6860 }
6861
6862
6863 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6864 PyObject *resultobj;
6865 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6866 wxPoint2D result;
6867 PyObject * obj0 = 0 ;
6868 char *kwnames[] = {
6869 (char *) "self", NULL
6870 };
6871
6872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6874 if (SWIG_arg_fail(1)) SWIG_fail;
6875 {
6876 PyThreadState* __tstate = wxPyBeginAllowThreads();
6877 result = (arg1)->operator -();
6878
6879 wxPyEndAllowThreads(__tstate);
6880 if (PyErr_Occurred()) SWIG_fail;
6881 }
6882 {
6883 wxPoint2D * resultptr;
6884 resultptr = new wxPoint2D((wxPoint2D &)(result));
6885 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6886 }
6887 return resultobj;
6888 fail:
6889 return NULL;
6890 }
6891
6892
6893 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6894 PyObject *resultobj;
6895 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6896 wxPoint2D *arg2 = 0 ;
6897 wxPoint2D *result;
6898 wxPoint2D temp2 ;
6899 PyObject * obj0 = 0 ;
6900 PyObject * obj1 = 0 ;
6901 char *kwnames[] = {
6902 (char *) "self",(char *) "pt", NULL
6903 };
6904
6905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6907 if (SWIG_arg_fail(1)) SWIG_fail;
6908 {
6909 arg2 = &temp2;
6910 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6911 }
6912 {
6913 PyThreadState* __tstate = wxPyBeginAllowThreads();
6914 {
6915 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6916 result = (wxPoint2D *) &_result_ref;
6917 }
6918
6919 wxPyEndAllowThreads(__tstate);
6920 if (PyErr_Occurred()) SWIG_fail;
6921 }
6922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6923 return resultobj;
6924 fail:
6925 return NULL;
6926 }
6927
6928
6929 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6930 PyObject *resultobj;
6931 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6932 wxPoint2D *arg2 = 0 ;
6933 wxPoint2D *result;
6934 wxPoint2D temp2 ;
6935 PyObject * obj0 = 0 ;
6936 PyObject * obj1 = 0 ;
6937 char *kwnames[] = {
6938 (char *) "self",(char *) "pt", NULL
6939 };
6940
6941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6943 if (SWIG_arg_fail(1)) SWIG_fail;
6944 {
6945 arg2 = &temp2;
6946 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6947 }
6948 {
6949 PyThreadState* __tstate = wxPyBeginAllowThreads();
6950 {
6951 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6952 result = (wxPoint2D *) &_result_ref;
6953 }
6954
6955 wxPyEndAllowThreads(__tstate);
6956 if (PyErr_Occurred()) SWIG_fail;
6957 }
6958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6959 return resultobj;
6960 fail:
6961 return NULL;
6962 }
6963
6964
6965 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
6966 PyObject *resultobj;
6967 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6968 wxPoint2D *arg2 = 0 ;
6969 wxPoint2D *result;
6970 wxPoint2D temp2 ;
6971 PyObject * obj0 = 0 ;
6972 PyObject * obj1 = 0 ;
6973 char *kwnames[] = {
6974 (char *) "self",(char *) "pt", NULL
6975 };
6976
6977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
6978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6979 if (SWIG_arg_fail(1)) SWIG_fail;
6980 {
6981 arg2 = &temp2;
6982 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6983 }
6984 {
6985 PyThreadState* __tstate = wxPyBeginAllowThreads();
6986 {
6987 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
6988 result = (wxPoint2D *) &_result_ref;
6989 }
6990
6991 wxPyEndAllowThreads(__tstate);
6992 if (PyErr_Occurred()) SWIG_fail;
6993 }
6994 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6995 return resultobj;
6996 fail:
6997 return NULL;
6998 }
6999
7000
7001 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7002 PyObject *resultobj;
7003 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7004 wxPoint2D *arg2 = 0 ;
7005 wxPoint2D *result;
7006 wxPoint2D temp2 ;
7007 PyObject * obj0 = 0 ;
7008 PyObject * obj1 = 0 ;
7009 char *kwnames[] = {
7010 (char *) "self",(char *) "pt", NULL
7011 };
7012
7013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7015 if (SWIG_arg_fail(1)) SWIG_fail;
7016 {
7017 arg2 = &temp2;
7018 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7019 }
7020 {
7021 PyThreadState* __tstate = wxPyBeginAllowThreads();
7022 {
7023 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7024 result = (wxPoint2D *) &_result_ref;
7025 }
7026
7027 wxPyEndAllowThreads(__tstate);
7028 if (PyErr_Occurred()) SWIG_fail;
7029 }
7030 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7031 return resultobj;
7032 fail:
7033 return NULL;
7034 }
7035
7036
7037 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7038 PyObject *resultobj;
7039 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7040 wxPoint2D *arg2 = 0 ;
7041 bool result;
7042 wxPoint2D temp2 ;
7043 PyObject * obj0 = 0 ;
7044 PyObject * obj1 = 0 ;
7045 char *kwnames[] = {
7046 (char *) "self",(char *) "pt", NULL
7047 };
7048
7049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7051 if (SWIG_arg_fail(1)) SWIG_fail;
7052 {
7053 arg2 = &temp2;
7054 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7055 }
7056 {
7057 PyThreadState* __tstate = wxPyBeginAllowThreads();
7058 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7059
7060 wxPyEndAllowThreads(__tstate);
7061 if (PyErr_Occurred()) SWIG_fail;
7062 }
7063 {
7064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7065 }
7066 return resultobj;
7067 fail:
7068 return NULL;
7069 }
7070
7071
7072 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7073 PyObject *resultobj;
7074 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7075 wxPoint2D *arg2 = 0 ;
7076 bool result;
7077 wxPoint2D temp2 ;
7078 PyObject * obj0 = 0 ;
7079 PyObject * obj1 = 0 ;
7080 char *kwnames[] = {
7081 (char *) "self",(char *) "pt", NULL
7082 };
7083
7084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7086 if (SWIG_arg_fail(1)) SWIG_fail;
7087 {
7088 arg2 = &temp2;
7089 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7090 }
7091 {
7092 PyThreadState* __tstate = wxPyBeginAllowThreads();
7093 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7094
7095 wxPyEndAllowThreads(__tstate);
7096 if (PyErr_Occurred()) SWIG_fail;
7097 }
7098 {
7099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7100 }
7101 return resultobj;
7102 fail:
7103 return NULL;
7104 }
7105
7106
7107 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7108 PyObject *resultobj;
7109 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7110 double arg2 ;
7111 PyObject * obj0 = 0 ;
7112 PyObject * obj1 = 0 ;
7113 char *kwnames[] = {
7114 (char *) "self",(char *) "m_x", NULL
7115 };
7116
7117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7119 if (SWIG_arg_fail(1)) SWIG_fail;
7120 {
7121 arg2 = (double)(SWIG_As_double(obj1));
7122 if (SWIG_arg_fail(2)) SWIG_fail;
7123 }
7124 if (arg1) (arg1)->m_x = arg2;
7125
7126 Py_INCREF(Py_None); resultobj = Py_None;
7127 return resultobj;
7128 fail:
7129 return NULL;
7130 }
7131
7132
7133 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7134 PyObject *resultobj;
7135 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7136 double result;
7137 PyObject * obj0 = 0 ;
7138 char *kwnames[] = {
7139 (char *) "self", NULL
7140 };
7141
7142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7144 if (SWIG_arg_fail(1)) SWIG_fail;
7145 result = (double) ((arg1)->m_x);
7146
7147 {
7148 resultobj = SWIG_From_double((double)(result));
7149 }
7150 return resultobj;
7151 fail:
7152 return NULL;
7153 }
7154
7155
7156 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7157 PyObject *resultobj;
7158 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7159 double arg2 ;
7160 PyObject * obj0 = 0 ;
7161 PyObject * obj1 = 0 ;
7162 char *kwnames[] = {
7163 (char *) "self",(char *) "m_y", NULL
7164 };
7165
7166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7168 if (SWIG_arg_fail(1)) SWIG_fail;
7169 {
7170 arg2 = (double)(SWIG_As_double(obj1));
7171 if (SWIG_arg_fail(2)) SWIG_fail;
7172 }
7173 if (arg1) (arg1)->m_y = arg2;
7174
7175 Py_INCREF(Py_None); resultobj = Py_None;
7176 return resultobj;
7177 fail:
7178 return NULL;
7179 }
7180
7181
7182 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7183 PyObject *resultobj;
7184 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7185 double result;
7186 PyObject * obj0 = 0 ;
7187 char *kwnames[] = {
7188 (char *) "self", NULL
7189 };
7190
7191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7193 if (SWIG_arg_fail(1)) SWIG_fail;
7194 result = (double) ((arg1)->m_y);
7195
7196 {
7197 resultobj = SWIG_From_double((double)(result));
7198 }
7199 return resultobj;
7200 fail:
7201 return NULL;
7202 }
7203
7204
7205 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7206 PyObject *resultobj;
7207 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7208 double arg2 = (double) 0 ;
7209 double arg3 = (double) 0 ;
7210 PyObject * obj0 = 0 ;
7211 PyObject * obj1 = 0 ;
7212 PyObject * obj2 = 0 ;
7213 char *kwnames[] = {
7214 (char *) "self",(char *) "x",(char *) "y", NULL
7215 };
7216
7217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7219 if (SWIG_arg_fail(1)) SWIG_fail;
7220 if (obj1) {
7221 {
7222 arg2 = (double)(SWIG_As_double(obj1));
7223 if (SWIG_arg_fail(2)) SWIG_fail;
7224 }
7225 }
7226 if (obj2) {
7227 {
7228 arg3 = (double)(SWIG_As_double(obj2));
7229 if (SWIG_arg_fail(3)) SWIG_fail;
7230 }
7231 }
7232 {
7233 PyThreadState* __tstate = wxPyBeginAllowThreads();
7234 wxPoint2D_Set(arg1,arg2,arg3);
7235
7236 wxPyEndAllowThreads(__tstate);
7237 if (PyErr_Occurred()) SWIG_fail;
7238 }
7239 Py_INCREF(Py_None); resultobj = Py_None;
7240 return resultobj;
7241 fail:
7242 return NULL;
7243 }
7244
7245
7246 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7247 PyObject *resultobj;
7248 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7249 PyObject *result;
7250 PyObject * obj0 = 0 ;
7251 char *kwnames[] = {
7252 (char *) "self", NULL
7253 };
7254
7255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7257 if (SWIG_arg_fail(1)) SWIG_fail;
7258 {
7259 PyThreadState* __tstate = wxPyBeginAllowThreads();
7260 result = (PyObject *)wxPoint2D_Get(arg1);
7261
7262 wxPyEndAllowThreads(__tstate);
7263 if (PyErr_Occurred()) SWIG_fail;
7264 }
7265 resultobj = result;
7266 return resultobj;
7267 fail:
7268 return NULL;
7269 }
7270
7271
7272 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7273 PyObject *obj;
7274 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7275 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7276 Py_INCREF(obj);
7277 return Py_BuildValue((char *)"");
7278 }
7279 static int _wrap_DefaultPosition_set(PyObject *) {
7280 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7281 return 1;
7282 }
7283
7284
7285 static PyObject *_wrap_DefaultPosition_get(void) {
7286 PyObject *pyobj;
7287
7288 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7289 return pyobj;
7290 }
7291
7292
7293 static int _wrap_DefaultSize_set(PyObject *) {
7294 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7295 return 1;
7296 }
7297
7298
7299 static PyObject *_wrap_DefaultSize_get(void) {
7300 PyObject *pyobj;
7301
7302 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7303 return pyobj;
7304 }
7305
7306
7307 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7308 PyObject *resultobj;
7309 PyObject *arg1 = (PyObject *) 0 ;
7310 wxPyInputStream *result;
7311 PyObject * obj0 = 0 ;
7312 char *kwnames[] = {
7313 (char *) "p", NULL
7314 };
7315
7316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7317 arg1 = obj0;
7318 {
7319 PyThreadState* __tstate = wxPyBeginAllowThreads();
7320 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7321
7322 wxPyEndAllowThreads(__tstate);
7323 if (PyErr_Occurred()) SWIG_fail;
7324 }
7325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7326 return resultobj;
7327 fail:
7328 return NULL;
7329 }
7330
7331
7332 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7333 PyObject *resultobj;
7334 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7335 PyObject * obj0 = 0 ;
7336 char *kwnames[] = {
7337 (char *) "self", NULL
7338 };
7339
7340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7342 if (SWIG_arg_fail(1)) SWIG_fail;
7343 {
7344 PyThreadState* __tstate = wxPyBeginAllowThreads();
7345 delete arg1;
7346
7347 wxPyEndAllowThreads(__tstate);
7348 if (PyErr_Occurred()) SWIG_fail;
7349 }
7350 Py_INCREF(Py_None); resultobj = Py_None;
7351 return resultobj;
7352 fail:
7353 return NULL;
7354 }
7355
7356
7357 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7358 PyObject *resultobj;
7359 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7360 PyObject * obj0 = 0 ;
7361 char *kwnames[] = {
7362 (char *) "self", NULL
7363 };
7364
7365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7367 if (SWIG_arg_fail(1)) SWIG_fail;
7368 {
7369 PyThreadState* __tstate = wxPyBeginAllowThreads();
7370 (arg1)->close();
7371
7372 wxPyEndAllowThreads(__tstate);
7373 if (PyErr_Occurred()) SWIG_fail;
7374 }
7375 Py_INCREF(Py_None); resultobj = Py_None;
7376 return resultobj;
7377 fail:
7378 return NULL;
7379 }
7380
7381
7382 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7383 PyObject *resultobj;
7384 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7385 PyObject * obj0 = 0 ;
7386 char *kwnames[] = {
7387 (char *) "self", NULL
7388 };
7389
7390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7392 if (SWIG_arg_fail(1)) SWIG_fail;
7393 {
7394 PyThreadState* __tstate = wxPyBeginAllowThreads();
7395 (arg1)->flush();
7396
7397 wxPyEndAllowThreads(__tstate);
7398 if (PyErr_Occurred()) SWIG_fail;
7399 }
7400 Py_INCREF(Py_None); resultobj = Py_None;
7401 return resultobj;
7402 fail:
7403 return NULL;
7404 }
7405
7406
7407 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7408 PyObject *resultobj;
7409 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7410 bool result;
7411 PyObject * obj0 = 0 ;
7412 char *kwnames[] = {
7413 (char *) "self", NULL
7414 };
7415
7416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7418 if (SWIG_arg_fail(1)) SWIG_fail;
7419 {
7420 PyThreadState* __tstate = wxPyBeginAllowThreads();
7421 result = (bool)(arg1)->eof();
7422
7423 wxPyEndAllowThreads(__tstate);
7424 if (PyErr_Occurred()) SWIG_fail;
7425 }
7426 {
7427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7428 }
7429 return resultobj;
7430 fail:
7431 return NULL;
7432 }
7433
7434
7435 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7436 PyObject *resultobj;
7437 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7438 int arg2 = (int) -1 ;
7439 PyObject *result;
7440 PyObject * obj0 = 0 ;
7441 PyObject * obj1 = 0 ;
7442 char *kwnames[] = {
7443 (char *) "self",(char *) "size", NULL
7444 };
7445
7446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7448 if (SWIG_arg_fail(1)) SWIG_fail;
7449 if (obj1) {
7450 {
7451 arg2 = (int)(SWIG_As_int(obj1));
7452 if (SWIG_arg_fail(2)) SWIG_fail;
7453 }
7454 }
7455 {
7456 PyThreadState* __tstate = wxPyBeginAllowThreads();
7457 result = (PyObject *)(arg1)->read(arg2);
7458
7459 wxPyEndAllowThreads(__tstate);
7460 if (PyErr_Occurred()) SWIG_fail;
7461 }
7462 resultobj = result;
7463 return resultobj;
7464 fail:
7465 return NULL;
7466 }
7467
7468
7469 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7470 PyObject *resultobj;
7471 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7472 int arg2 = (int) -1 ;
7473 PyObject *result;
7474 PyObject * obj0 = 0 ;
7475 PyObject * obj1 = 0 ;
7476 char *kwnames[] = {
7477 (char *) "self",(char *) "size", NULL
7478 };
7479
7480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7482 if (SWIG_arg_fail(1)) SWIG_fail;
7483 if (obj1) {
7484 {
7485 arg2 = (int)(SWIG_As_int(obj1));
7486 if (SWIG_arg_fail(2)) SWIG_fail;
7487 }
7488 }
7489 {
7490 PyThreadState* __tstate = wxPyBeginAllowThreads();
7491 result = (PyObject *)(arg1)->readline(arg2);
7492
7493 wxPyEndAllowThreads(__tstate);
7494 if (PyErr_Occurred()) SWIG_fail;
7495 }
7496 resultobj = result;
7497 return resultobj;
7498 fail:
7499 return NULL;
7500 }
7501
7502
7503 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7504 PyObject *resultobj;
7505 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7506 int arg2 = (int) -1 ;
7507 PyObject *result;
7508 PyObject * obj0 = 0 ;
7509 PyObject * obj1 = 0 ;
7510 char *kwnames[] = {
7511 (char *) "self",(char *) "sizehint", NULL
7512 };
7513
7514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7516 if (SWIG_arg_fail(1)) SWIG_fail;
7517 if (obj1) {
7518 {
7519 arg2 = (int)(SWIG_As_int(obj1));
7520 if (SWIG_arg_fail(2)) SWIG_fail;
7521 }
7522 }
7523 {
7524 PyThreadState* __tstate = wxPyBeginAllowThreads();
7525 result = (PyObject *)(arg1)->readlines(arg2);
7526
7527 wxPyEndAllowThreads(__tstate);
7528 if (PyErr_Occurred()) SWIG_fail;
7529 }
7530 resultobj = result;
7531 return resultobj;
7532 fail:
7533 return NULL;
7534 }
7535
7536
7537 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7538 PyObject *resultobj;
7539 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7540 int arg2 ;
7541 int arg3 = (int) 0 ;
7542 PyObject * obj0 = 0 ;
7543 PyObject * obj1 = 0 ;
7544 PyObject * obj2 = 0 ;
7545 char *kwnames[] = {
7546 (char *) "self",(char *) "offset",(char *) "whence", NULL
7547 };
7548
7549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7551 if (SWIG_arg_fail(1)) SWIG_fail;
7552 {
7553 arg2 = (int)(SWIG_As_int(obj1));
7554 if (SWIG_arg_fail(2)) SWIG_fail;
7555 }
7556 if (obj2) {
7557 {
7558 arg3 = (int)(SWIG_As_int(obj2));
7559 if (SWIG_arg_fail(3)) SWIG_fail;
7560 }
7561 }
7562 {
7563 PyThreadState* __tstate = wxPyBeginAllowThreads();
7564 (arg1)->seek(arg2,arg3);
7565
7566 wxPyEndAllowThreads(__tstate);
7567 if (PyErr_Occurred()) SWIG_fail;
7568 }
7569 Py_INCREF(Py_None); resultobj = Py_None;
7570 return resultobj;
7571 fail:
7572 return NULL;
7573 }
7574
7575
7576 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7577 PyObject *resultobj;
7578 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7579 int result;
7580 PyObject * obj0 = 0 ;
7581 char *kwnames[] = {
7582 (char *) "self", NULL
7583 };
7584
7585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7587 if (SWIG_arg_fail(1)) SWIG_fail;
7588 {
7589 PyThreadState* __tstate = wxPyBeginAllowThreads();
7590 result = (int)(arg1)->tell();
7591
7592 wxPyEndAllowThreads(__tstate);
7593 if (PyErr_Occurred()) SWIG_fail;
7594 }
7595 {
7596 resultobj = SWIG_From_int((int)(result));
7597 }
7598 return resultobj;
7599 fail:
7600 return NULL;
7601 }
7602
7603
7604 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7605 PyObject *resultobj;
7606 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7607 char result;
7608 PyObject * obj0 = 0 ;
7609 char *kwnames[] = {
7610 (char *) "self", NULL
7611 };
7612
7613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7615 if (SWIG_arg_fail(1)) SWIG_fail;
7616 {
7617 PyThreadState* __tstate = wxPyBeginAllowThreads();
7618 result = (char)(arg1)->Peek();
7619
7620 wxPyEndAllowThreads(__tstate);
7621 if (PyErr_Occurred()) SWIG_fail;
7622 }
7623 {
7624 resultobj = SWIG_From_char((char)(result));
7625 }
7626 return resultobj;
7627 fail:
7628 return NULL;
7629 }
7630
7631
7632 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7633 PyObject *resultobj;
7634 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7635 char result;
7636 PyObject * obj0 = 0 ;
7637 char *kwnames[] = {
7638 (char *) "self", NULL
7639 };
7640
7641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7643 if (SWIG_arg_fail(1)) SWIG_fail;
7644 {
7645 PyThreadState* __tstate = wxPyBeginAllowThreads();
7646 result = (char)(arg1)->GetC();
7647
7648 wxPyEndAllowThreads(__tstate);
7649 if (PyErr_Occurred()) SWIG_fail;
7650 }
7651 {
7652 resultobj = SWIG_From_char((char)(result));
7653 }
7654 return resultobj;
7655 fail:
7656 return NULL;
7657 }
7658
7659
7660 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7661 PyObject *resultobj;
7662 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7663 size_t result;
7664 PyObject * obj0 = 0 ;
7665 char *kwnames[] = {
7666 (char *) "self", NULL
7667 };
7668
7669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7671 if (SWIG_arg_fail(1)) SWIG_fail;
7672 {
7673 PyThreadState* __tstate = wxPyBeginAllowThreads();
7674 result = (size_t)(arg1)->LastRead();
7675
7676 wxPyEndAllowThreads(__tstate);
7677 if (PyErr_Occurred()) SWIG_fail;
7678 }
7679 {
7680 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7681 }
7682 return resultobj;
7683 fail:
7684 return NULL;
7685 }
7686
7687
7688 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7689 PyObject *resultobj;
7690 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7691 bool result;
7692 PyObject * obj0 = 0 ;
7693 char *kwnames[] = {
7694 (char *) "self", NULL
7695 };
7696
7697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7699 if (SWIG_arg_fail(1)) SWIG_fail;
7700 {
7701 PyThreadState* __tstate = wxPyBeginAllowThreads();
7702 result = (bool)(arg1)->CanRead();
7703
7704 wxPyEndAllowThreads(__tstate);
7705 if (PyErr_Occurred()) SWIG_fail;
7706 }
7707 {
7708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7709 }
7710 return resultobj;
7711 fail:
7712 return NULL;
7713 }
7714
7715
7716 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7717 PyObject *resultobj;
7718 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7719 bool result;
7720 PyObject * obj0 = 0 ;
7721 char *kwnames[] = {
7722 (char *) "self", NULL
7723 };
7724
7725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7727 if (SWIG_arg_fail(1)) SWIG_fail;
7728 {
7729 PyThreadState* __tstate = wxPyBeginAllowThreads();
7730 result = (bool)(arg1)->Eof();
7731
7732 wxPyEndAllowThreads(__tstate);
7733 if (PyErr_Occurred()) SWIG_fail;
7734 }
7735 {
7736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7737 }
7738 return resultobj;
7739 fail:
7740 return NULL;
7741 }
7742
7743
7744 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7745 PyObject *resultobj;
7746 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7747 char arg2 ;
7748 bool result;
7749 PyObject * obj0 = 0 ;
7750 PyObject * obj1 = 0 ;
7751 char *kwnames[] = {
7752 (char *) "self",(char *) "c", NULL
7753 };
7754
7755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7757 if (SWIG_arg_fail(1)) SWIG_fail;
7758 {
7759 arg2 = (char)(SWIG_As_char(obj1));
7760 if (SWIG_arg_fail(2)) SWIG_fail;
7761 }
7762 {
7763 PyThreadState* __tstate = wxPyBeginAllowThreads();
7764 result = (bool)(arg1)->Ungetch(arg2);
7765
7766 wxPyEndAllowThreads(__tstate);
7767 if (PyErr_Occurred()) SWIG_fail;
7768 }
7769 {
7770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7771 }
7772 return resultobj;
7773 fail:
7774 return NULL;
7775 }
7776
7777
7778 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7779 PyObject *resultobj;
7780 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7781 long arg2 ;
7782 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7783 long result;
7784 PyObject * obj0 = 0 ;
7785 PyObject * obj1 = 0 ;
7786 PyObject * obj2 = 0 ;
7787 char *kwnames[] = {
7788 (char *) "self",(char *) "pos",(char *) "mode", NULL
7789 };
7790
7791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7793 if (SWIG_arg_fail(1)) SWIG_fail;
7794 {
7795 arg2 = (long)(SWIG_As_long(obj1));
7796 if (SWIG_arg_fail(2)) SWIG_fail;
7797 }
7798 if (obj2) {
7799 {
7800 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7801 if (SWIG_arg_fail(3)) SWIG_fail;
7802 }
7803 }
7804 {
7805 PyThreadState* __tstate = wxPyBeginAllowThreads();
7806 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7807
7808 wxPyEndAllowThreads(__tstate);
7809 if (PyErr_Occurred()) SWIG_fail;
7810 }
7811 {
7812 resultobj = SWIG_From_long((long)(result));
7813 }
7814 return resultobj;
7815 fail:
7816 return NULL;
7817 }
7818
7819
7820 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7821 PyObject *resultobj;
7822 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7823 long result;
7824 PyObject * obj0 = 0 ;
7825 char *kwnames[] = {
7826 (char *) "self", NULL
7827 };
7828
7829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7831 if (SWIG_arg_fail(1)) SWIG_fail;
7832 {
7833 PyThreadState* __tstate = wxPyBeginAllowThreads();
7834 result = (long)(arg1)->TellI();
7835
7836 wxPyEndAllowThreads(__tstate);
7837 if (PyErr_Occurred()) SWIG_fail;
7838 }
7839 {
7840 resultobj = SWIG_From_long((long)(result));
7841 }
7842 return resultobj;
7843 fail:
7844 return NULL;
7845 }
7846
7847
7848 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7849 PyObject *obj;
7850 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7851 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7852 Py_INCREF(obj);
7853 return Py_BuildValue((char *)"");
7854 }
7855 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7856 PyObject *resultobj;
7857 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7858 PyObject *arg2 = (PyObject *) 0 ;
7859 PyObject * obj0 = 0 ;
7860 PyObject * obj1 = 0 ;
7861 char *kwnames[] = {
7862 (char *) "self",(char *) "obj", NULL
7863 };
7864
7865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7867 if (SWIG_arg_fail(1)) SWIG_fail;
7868 arg2 = obj1;
7869 {
7870 PyThreadState* __tstate = wxPyBeginAllowThreads();
7871 wxOutputStream_write(arg1,arg2);
7872
7873 wxPyEndAllowThreads(__tstate);
7874 if (PyErr_Occurred()) SWIG_fail;
7875 }
7876 Py_INCREF(Py_None); resultobj = Py_None;
7877 return resultobj;
7878 fail:
7879 return NULL;
7880 }
7881
7882
7883 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7884 PyObject *obj;
7885 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7886 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7887 Py_INCREF(obj);
7888 return Py_BuildValue((char *)"");
7889 }
7890 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7891 PyObject *resultobj;
7892 wxInputStream *arg1 = (wxInputStream *) 0 ;
7893 wxString *arg2 = 0 ;
7894 wxString *arg3 = 0 ;
7895 wxString *arg4 = 0 ;
7896 wxDateTime arg5 ;
7897 wxFSFile *result;
7898 wxPyInputStream *temp1 ;
7899 bool created1 ;
7900 bool temp2 = false ;
7901 bool temp3 = false ;
7902 bool temp4 = false ;
7903 PyObject * obj0 = 0 ;
7904 PyObject * obj1 = 0 ;
7905 PyObject * obj2 = 0 ;
7906 PyObject * obj3 = 0 ;
7907 PyObject * obj4 = 0 ;
7908 char *kwnames[] = {
7909 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7910 };
7911
7912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7913 {
7914 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7915 arg1 = temp1->m_wxis;
7916 created1 = false;
7917 } else {
7918 PyErr_Clear(); // clear the failure of the wxPyConvert above
7919 arg1 = wxPyCBInputStream_create(obj0, false);
7920 if (arg1 == NULL) {
7921 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
7922 SWIG_fail;
7923 }
7924 created1 = true;
7925 }
7926 }
7927 {
7928 arg2 = wxString_in_helper(obj1);
7929 if (arg2 == NULL) SWIG_fail;
7930 temp2 = true;
7931 }
7932 {
7933 arg3 = wxString_in_helper(obj2);
7934 if (arg3 == NULL) SWIG_fail;
7935 temp3 = true;
7936 }
7937 {
7938 arg4 = wxString_in_helper(obj3);
7939 if (arg4 == NULL) SWIG_fail;
7940 temp4 = true;
7941 }
7942 {
7943 wxDateTime * argp;
7944 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7945 if (SWIG_arg_fail(5)) SWIG_fail;
7946 if (argp == NULL) {
7947 SWIG_null_ref("wxDateTime");
7948 }
7949 if (SWIG_arg_fail(5)) SWIG_fail;
7950 arg5 = *argp;
7951 }
7952 {
7953 PyThreadState* __tstate = wxPyBeginAllowThreads();
7954 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7955
7956 wxPyEndAllowThreads(__tstate);
7957 if (PyErr_Occurred()) SWIG_fail;
7958 }
7959 {
7960 resultobj = wxPyMake_wxObject(result, 1);
7961 }
7962 {
7963 if (created1)
7964 delete arg1;
7965 }
7966 {
7967 if (temp2)
7968 delete arg2;
7969 }
7970 {
7971 if (temp3)
7972 delete arg3;
7973 }
7974 {
7975 if (temp4)
7976 delete arg4;
7977 }
7978 return resultobj;
7979 fail:
7980 {
7981 if (created1)
7982 delete arg1;
7983 }
7984 {
7985 if (temp2)
7986 delete arg2;
7987 }
7988 {
7989 if (temp3)
7990 delete arg3;
7991 }
7992 {
7993 if (temp4)
7994 delete arg4;
7995 }
7996 return NULL;
7997 }
7998
7999
8000 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8001 PyObject *resultobj;
8002 wxFSFile *arg1 = (wxFSFile *) 0 ;
8003 PyObject * obj0 = 0 ;
8004 char *kwnames[] = {
8005 (char *) "self", NULL
8006 };
8007
8008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8010 if (SWIG_arg_fail(1)) SWIG_fail;
8011 {
8012 PyThreadState* __tstate = wxPyBeginAllowThreads();
8013 delete arg1;
8014
8015 wxPyEndAllowThreads(__tstate);
8016 if (PyErr_Occurred()) SWIG_fail;
8017 }
8018 Py_INCREF(Py_None); resultobj = Py_None;
8019 return resultobj;
8020 fail:
8021 return NULL;
8022 }
8023
8024
8025 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8026 PyObject *resultobj;
8027 wxFSFile *arg1 = (wxFSFile *) 0 ;
8028 wxInputStream *result;
8029 PyObject * obj0 = 0 ;
8030 char *kwnames[] = {
8031 (char *) "self", NULL
8032 };
8033
8034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8036 if (SWIG_arg_fail(1)) SWIG_fail;
8037 {
8038 PyThreadState* __tstate = wxPyBeginAllowThreads();
8039 result = (wxInputStream *)(arg1)->GetStream();
8040
8041 wxPyEndAllowThreads(__tstate);
8042 if (PyErr_Occurred()) SWIG_fail;
8043 }
8044 {
8045 wxPyInputStream * _ptr = NULL;
8046
8047 if (result) {
8048 _ptr = new wxPyInputStream(result);
8049 }
8050 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8051 }
8052 return resultobj;
8053 fail:
8054 return NULL;
8055 }
8056
8057
8058 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8059 PyObject *resultobj;
8060 wxFSFile *arg1 = (wxFSFile *) 0 ;
8061 wxString *result;
8062 PyObject * obj0 = 0 ;
8063 char *kwnames[] = {
8064 (char *) "self", NULL
8065 };
8066
8067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8069 if (SWIG_arg_fail(1)) SWIG_fail;
8070 {
8071 PyThreadState* __tstate = wxPyBeginAllowThreads();
8072 {
8073 wxString const &_result_ref = (arg1)->GetMimeType();
8074 result = (wxString *) &_result_ref;
8075 }
8076
8077 wxPyEndAllowThreads(__tstate);
8078 if (PyErr_Occurred()) SWIG_fail;
8079 }
8080 {
8081 #if wxUSE_UNICODE
8082 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8083 #else
8084 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8085 #endif
8086 }
8087 return resultobj;
8088 fail:
8089 return NULL;
8090 }
8091
8092
8093 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8094 PyObject *resultobj;
8095 wxFSFile *arg1 = (wxFSFile *) 0 ;
8096 wxString *result;
8097 PyObject * obj0 = 0 ;
8098 char *kwnames[] = {
8099 (char *) "self", NULL
8100 };
8101
8102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8104 if (SWIG_arg_fail(1)) SWIG_fail;
8105 {
8106 PyThreadState* __tstate = wxPyBeginAllowThreads();
8107 {
8108 wxString const &_result_ref = (arg1)->GetLocation();
8109 result = (wxString *) &_result_ref;
8110 }
8111
8112 wxPyEndAllowThreads(__tstate);
8113 if (PyErr_Occurred()) SWIG_fail;
8114 }
8115 {
8116 #if wxUSE_UNICODE
8117 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8118 #else
8119 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8120 #endif
8121 }
8122 return resultobj;
8123 fail:
8124 return NULL;
8125 }
8126
8127
8128 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8129 PyObject *resultobj;
8130 wxFSFile *arg1 = (wxFSFile *) 0 ;
8131 wxString *result;
8132 PyObject * obj0 = 0 ;
8133 char *kwnames[] = {
8134 (char *) "self", NULL
8135 };
8136
8137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8139 if (SWIG_arg_fail(1)) SWIG_fail;
8140 {
8141 PyThreadState* __tstate = wxPyBeginAllowThreads();
8142 {
8143 wxString const &_result_ref = (arg1)->GetAnchor();
8144 result = (wxString *) &_result_ref;
8145 }
8146
8147 wxPyEndAllowThreads(__tstate);
8148 if (PyErr_Occurred()) SWIG_fail;
8149 }
8150 {
8151 #if wxUSE_UNICODE
8152 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8153 #else
8154 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8155 #endif
8156 }
8157 return resultobj;
8158 fail:
8159 return NULL;
8160 }
8161
8162
8163 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8164 PyObject *resultobj;
8165 wxFSFile *arg1 = (wxFSFile *) 0 ;
8166 wxDateTime result;
8167 PyObject * obj0 = 0 ;
8168 char *kwnames[] = {
8169 (char *) "self", NULL
8170 };
8171
8172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8174 if (SWIG_arg_fail(1)) SWIG_fail;
8175 {
8176 PyThreadState* __tstate = wxPyBeginAllowThreads();
8177 result = (arg1)->GetModificationTime();
8178
8179 wxPyEndAllowThreads(__tstate);
8180 if (PyErr_Occurred()) SWIG_fail;
8181 }
8182 {
8183 wxDateTime * resultptr;
8184 resultptr = new wxDateTime((wxDateTime &)(result));
8185 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8186 }
8187 return resultobj;
8188 fail:
8189 return NULL;
8190 }
8191
8192
8193 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8194 PyObject *obj;
8195 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8196 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8197 Py_INCREF(obj);
8198 return Py_BuildValue((char *)"");
8199 }
8200 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8201 PyObject *obj;
8202 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8203 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8204 Py_INCREF(obj);
8205 return Py_BuildValue((char *)"");
8206 }
8207 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8208 PyObject *resultobj;
8209 wxPyFileSystemHandler *result;
8210 char *kwnames[] = {
8211 NULL
8212 };
8213
8214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8215 {
8216 PyThreadState* __tstate = wxPyBeginAllowThreads();
8217 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8218
8219 wxPyEndAllowThreads(__tstate);
8220 if (PyErr_Occurred()) SWIG_fail;
8221 }
8222 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8223 return resultobj;
8224 fail:
8225 return NULL;
8226 }
8227
8228
8229 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8230 PyObject *resultobj;
8231 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8232 PyObject *arg2 = (PyObject *) 0 ;
8233 PyObject *arg3 = (PyObject *) 0 ;
8234 PyObject * obj0 = 0 ;
8235 PyObject * obj1 = 0 ;
8236 PyObject * obj2 = 0 ;
8237 char *kwnames[] = {
8238 (char *) "self",(char *) "self",(char *) "_class", NULL
8239 };
8240
8241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8243 if (SWIG_arg_fail(1)) SWIG_fail;
8244 arg2 = obj1;
8245 arg3 = obj2;
8246 {
8247 PyThreadState* __tstate = wxPyBeginAllowThreads();
8248 (arg1)->_setCallbackInfo(arg2,arg3);
8249
8250 wxPyEndAllowThreads(__tstate);
8251 if (PyErr_Occurred()) SWIG_fail;
8252 }
8253 Py_INCREF(Py_None); resultobj = Py_None;
8254 return resultobj;
8255 fail:
8256 return NULL;
8257 }
8258
8259
8260 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8261 PyObject *resultobj;
8262 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8263 wxString *arg2 = 0 ;
8264 bool result;
8265 bool temp2 = false ;
8266 PyObject * obj0 = 0 ;
8267 PyObject * obj1 = 0 ;
8268 char *kwnames[] = {
8269 (char *) "self",(char *) "location", NULL
8270 };
8271
8272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8274 if (SWIG_arg_fail(1)) SWIG_fail;
8275 {
8276 arg2 = wxString_in_helper(obj1);
8277 if (arg2 == NULL) SWIG_fail;
8278 temp2 = true;
8279 }
8280 {
8281 PyThreadState* __tstate = wxPyBeginAllowThreads();
8282 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8283
8284 wxPyEndAllowThreads(__tstate);
8285 if (PyErr_Occurred()) SWIG_fail;
8286 }
8287 {
8288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8289 }
8290 {
8291 if (temp2)
8292 delete arg2;
8293 }
8294 return resultobj;
8295 fail:
8296 {
8297 if (temp2)
8298 delete arg2;
8299 }
8300 return NULL;
8301 }
8302
8303
8304 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8305 PyObject *resultobj;
8306 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8307 wxFileSystem *arg2 = 0 ;
8308 wxString *arg3 = 0 ;
8309 wxFSFile *result;
8310 bool temp3 = false ;
8311 PyObject * obj0 = 0 ;
8312 PyObject * obj1 = 0 ;
8313 PyObject * obj2 = 0 ;
8314 char *kwnames[] = {
8315 (char *) "self",(char *) "fs",(char *) "location", NULL
8316 };
8317
8318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8320 if (SWIG_arg_fail(1)) SWIG_fail;
8321 {
8322 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8323 if (SWIG_arg_fail(2)) SWIG_fail;
8324 if (arg2 == NULL) {
8325 SWIG_null_ref("wxFileSystem");
8326 }
8327 if (SWIG_arg_fail(2)) SWIG_fail;
8328 }
8329 {
8330 arg3 = wxString_in_helper(obj2);
8331 if (arg3 == NULL) SWIG_fail;
8332 temp3 = true;
8333 }
8334 {
8335 PyThreadState* __tstate = wxPyBeginAllowThreads();
8336 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8337
8338 wxPyEndAllowThreads(__tstate);
8339 if (PyErr_Occurred()) SWIG_fail;
8340 }
8341 {
8342 resultobj = wxPyMake_wxObject(result, 1);
8343 }
8344 {
8345 if (temp3)
8346 delete arg3;
8347 }
8348 return resultobj;
8349 fail:
8350 {
8351 if (temp3)
8352 delete arg3;
8353 }
8354 return NULL;
8355 }
8356
8357
8358 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8359 PyObject *resultobj;
8360 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8361 wxString *arg2 = 0 ;
8362 int arg3 = (int) 0 ;
8363 wxString result;
8364 bool temp2 = false ;
8365 PyObject * obj0 = 0 ;
8366 PyObject * obj1 = 0 ;
8367 PyObject * obj2 = 0 ;
8368 char *kwnames[] = {
8369 (char *) "self",(char *) "spec",(char *) "flags", NULL
8370 };
8371
8372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8374 if (SWIG_arg_fail(1)) SWIG_fail;
8375 {
8376 arg2 = wxString_in_helper(obj1);
8377 if (arg2 == NULL) SWIG_fail;
8378 temp2 = true;
8379 }
8380 if (obj2) {
8381 {
8382 arg3 = (int)(SWIG_As_int(obj2));
8383 if (SWIG_arg_fail(3)) SWIG_fail;
8384 }
8385 }
8386 {
8387 PyThreadState* __tstate = wxPyBeginAllowThreads();
8388 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8389
8390 wxPyEndAllowThreads(__tstate);
8391 if (PyErr_Occurred()) SWIG_fail;
8392 }
8393 {
8394 #if wxUSE_UNICODE
8395 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8396 #else
8397 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8398 #endif
8399 }
8400 {
8401 if (temp2)
8402 delete arg2;
8403 }
8404 return resultobj;
8405 fail:
8406 {
8407 if (temp2)
8408 delete arg2;
8409 }
8410 return NULL;
8411 }
8412
8413
8414 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8415 PyObject *resultobj;
8416 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8417 wxString result;
8418 PyObject * obj0 = 0 ;
8419 char *kwnames[] = {
8420 (char *) "self", NULL
8421 };
8422
8423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8425 if (SWIG_arg_fail(1)) SWIG_fail;
8426 {
8427 PyThreadState* __tstate = wxPyBeginAllowThreads();
8428 result = (arg1)->FindNext();
8429
8430 wxPyEndAllowThreads(__tstate);
8431 if (PyErr_Occurred()) SWIG_fail;
8432 }
8433 {
8434 #if wxUSE_UNICODE
8435 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8436 #else
8437 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8438 #endif
8439 }
8440 return resultobj;
8441 fail:
8442 return NULL;
8443 }
8444
8445
8446 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8447 PyObject *resultobj;
8448 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8449 wxString *arg2 = 0 ;
8450 wxString result;
8451 bool temp2 = false ;
8452 PyObject * obj0 = 0 ;
8453 PyObject * obj1 = 0 ;
8454 char *kwnames[] = {
8455 (char *) "self",(char *) "location", NULL
8456 };
8457
8458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8460 if (SWIG_arg_fail(1)) SWIG_fail;
8461 {
8462 arg2 = wxString_in_helper(obj1);
8463 if (arg2 == NULL) SWIG_fail;
8464 temp2 = true;
8465 }
8466 {
8467 PyThreadState* __tstate = wxPyBeginAllowThreads();
8468 result = (arg1)->GetProtocol((wxString const &)*arg2);
8469
8470 wxPyEndAllowThreads(__tstate);
8471 if (PyErr_Occurred()) SWIG_fail;
8472 }
8473 {
8474 #if wxUSE_UNICODE
8475 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8476 #else
8477 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8478 #endif
8479 }
8480 {
8481 if (temp2)
8482 delete arg2;
8483 }
8484 return resultobj;
8485 fail:
8486 {
8487 if (temp2)
8488 delete arg2;
8489 }
8490 return NULL;
8491 }
8492
8493
8494 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8495 PyObject *resultobj;
8496 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8497 wxString *arg2 = 0 ;
8498 wxString result;
8499 bool temp2 = false ;
8500 PyObject * obj0 = 0 ;
8501 PyObject * obj1 = 0 ;
8502 char *kwnames[] = {
8503 (char *) "self",(char *) "location", NULL
8504 };
8505
8506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8508 if (SWIG_arg_fail(1)) SWIG_fail;
8509 {
8510 arg2 = wxString_in_helper(obj1);
8511 if (arg2 == NULL) SWIG_fail;
8512 temp2 = true;
8513 }
8514 {
8515 PyThreadState* __tstate = wxPyBeginAllowThreads();
8516 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8517
8518 wxPyEndAllowThreads(__tstate);
8519 if (PyErr_Occurred()) SWIG_fail;
8520 }
8521 {
8522 #if wxUSE_UNICODE
8523 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8524 #else
8525 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8526 #endif
8527 }
8528 {
8529 if (temp2)
8530 delete arg2;
8531 }
8532 return resultobj;
8533 fail:
8534 {
8535 if (temp2)
8536 delete arg2;
8537 }
8538 return NULL;
8539 }
8540
8541
8542 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8543 PyObject *resultobj;
8544 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8545 wxString *arg2 = 0 ;
8546 wxString result;
8547 bool temp2 = false ;
8548 PyObject * obj0 = 0 ;
8549 PyObject * obj1 = 0 ;
8550 char *kwnames[] = {
8551 (char *) "self",(char *) "location", NULL
8552 };
8553
8554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8556 if (SWIG_arg_fail(1)) SWIG_fail;
8557 {
8558 arg2 = wxString_in_helper(obj1);
8559 if (arg2 == NULL) SWIG_fail;
8560 temp2 = true;
8561 }
8562 {
8563 PyThreadState* __tstate = wxPyBeginAllowThreads();
8564 result = (arg1)->GetAnchor((wxString const &)*arg2);
8565
8566 wxPyEndAllowThreads(__tstate);
8567 if (PyErr_Occurred()) SWIG_fail;
8568 }
8569 {
8570 #if wxUSE_UNICODE
8571 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8572 #else
8573 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8574 #endif
8575 }
8576 {
8577 if (temp2)
8578 delete arg2;
8579 }
8580 return resultobj;
8581 fail:
8582 {
8583 if (temp2)
8584 delete arg2;
8585 }
8586 return NULL;
8587 }
8588
8589
8590 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8591 PyObject *resultobj;
8592 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8593 wxString *arg2 = 0 ;
8594 wxString result;
8595 bool temp2 = false ;
8596 PyObject * obj0 = 0 ;
8597 PyObject * obj1 = 0 ;
8598 char *kwnames[] = {
8599 (char *) "self",(char *) "location", NULL
8600 };
8601
8602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8604 if (SWIG_arg_fail(1)) SWIG_fail;
8605 {
8606 arg2 = wxString_in_helper(obj1);
8607 if (arg2 == NULL) SWIG_fail;
8608 temp2 = true;
8609 }
8610 {
8611 PyThreadState* __tstate = wxPyBeginAllowThreads();
8612 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8613
8614 wxPyEndAllowThreads(__tstate);
8615 if (PyErr_Occurred()) SWIG_fail;
8616 }
8617 {
8618 #if wxUSE_UNICODE
8619 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8620 #else
8621 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8622 #endif
8623 }
8624 {
8625 if (temp2)
8626 delete arg2;
8627 }
8628 return resultobj;
8629 fail:
8630 {
8631 if (temp2)
8632 delete arg2;
8633 }
8634 return NULL;
8635 }
8636
8637
8638 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8639 PyObject *resultobj;
8640 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8641 wxString *arg2 = 0 ;
8642 wxString result;
8643 bool temp2 = false ;
8644 PyObject * obj0 = 0 ;
8645 PyObject * obj1 = 0 ;
8646 char *kwnames[] = {
8647 (char *) "self",(char *) "location", NULL
8648 };
8649
8650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8652 if (SWIG_arg_fail(1)) SWIG_fail;
8653 {
8654 arg2 = wxString_in_helper(obj1);
8655 if (arg2 == NULL) SWIG_fail;
8656 temp2 = true;
8657 }
8658 {
8659 PyThreadState* __tstate = wxPyBeginAllowThreads();
8660 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8661
8662 wxPyEndAllowThreads(__tstate);
8663 if (PyErr_Occurred()) SWIG_fail;
8664 }
8665 {
8666 #if wxUSE_UNICODE
8667 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8668 #else
8669 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8670 #endif
8671 }
8672 {
8673 if (temp2)
8674 delete arg2;
8675 }
8676 return resultobj;
8677 fail:
8678 {
8679 if (temp2)
8680 delete arg2;
8681 }
8682 return NULL;
8683 }
8684
8685
8686 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8687 PyObject *obj;
8688 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8689 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8690 Py_INCREF(obj);
8691 return Py_BuildValue((char *)"");
8692 }
8693 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8694 PyObject *resultobj;
8695 wxFileSystem *result;
8696 char *kwnames[] = {
8697 NULL
8698 };
8699
8700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8701 {
8702 PyThreadState* __tstate = wxPyBeginAllowThreads();
8703 result = (wxFileSystem *)new wxFileSystem();
8704
8705 wxPyEndAllowThreads(__tstate);
8706 if (PyErr_Occurred()) SWIG_fail;
8707 }
8708 {
8709 resultobj = wxPyMake_wxObject(result, 1);
8710 }
8711 return resultobj;
8712 fail:
8713 return NULL;
8714 }
8715
8716
8717 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8718 PyObject *resultobj;
8719 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8720 PyObject * obj0 = 0 ;
8721 char *kwnames[] = {
8722 (char *) "self", NULL
8723 };
8724
8725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8727 if (SWIG_arg_fail(1)) SWIG_fail;
8728 {
8729 PyThreadState* __tstate = wxPyBeginAllowThreads();
8730 delete arg1;
8731
8732 wxPyEndAllowThreads(__tstate);
8733 if (PyErr_Occurred()) SWIG_fail;
8734 }
8735 Py_INCREF(Py_None); resultobj = Py_None;
8736 return resultobj;
8737 fail:
8738 return NULL;
8739 }
8740
8741
8742 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8743 PyObject *resultobj;
8744 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8745 wxString *arg2 = 0 ;
8746 bool arg3 = (bool) false ;
8747 bool temp2 = false ;
8748 PyObject * obj0 = 0 ;
8749 PyObject * obj1 = 0 ;
8750 PyObject * obj2 = 0 ;
8751 char *kwnames[] = {
8752 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8753 };
8754
8755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8757 if (SWIG_arg_fail(1)) SWIG_fail;
8758 {
8759 arg2 = wxString_in_helper(obj1);
8760 if (arg2 == NULL) SWIG_fail;
8761 temp2 = true;
8762 }
8763 if (obj2) {
8764 {
8765 arg3 = (bool)(SWIG_As_bool(obj2));
8766 if (SWIG_arg_fail(3)) SWIG_fail;
8767 }
8768 }
8769 {
8770 PyThreadState* __tstate = wxPyBeginAllowThreads();
8771 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8772
8773 wxPyEndAllowThreads(__tstate);
8774 if (PyErr_Occurred()) SWIG_fail;
8775 }
8776 Py_INCREF(Py_None); resultobj = Py_None;
8777 {
8778 if (temp2)
8779 delete arg2;
8780 }
8781 return resultobj;
8782 fail:
8783 {
8784 if (temp2)
8785 delete arg2;
8786 }
8787 return NULL;
8788 }
8789
8790
8791 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8792 PyObject *resultobj;
8793 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8794 wxString result;
8795 PyObject * obj0 = 0 ;
8796 char *kwnames[] = {
8797 (char *) "self", NULL
8798 };
8799
8800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8802 if (SWIG_arg_fail(1)) SWIG_fail;
8803 {
8804 PyThreadState* __tstate = wxPyBeginAllowThreads();
8805 result = (arg1)->GetPath();
8806
8807 wxPyEndAllowThreads(__tstate);
8808 if (PyErr_Occurred()) SWIG_fail;
8809 }
8810 {
8811 #if wxUSE_UNICODE
8812 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8813 #else
8814 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8815 #endif
8816 }
8817 return resultobj;
8818 fail:
8819 return NULL;
8820 }
8821
8822
8823 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8824 PyObject *resultobj;
8825 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8826 wxString *arg2 = 0 ;
8827 wxFSFile *result;
8828 bool temp2 = false ;
8829 PyObject * obj0 = 0 ;
8830 PyObject * obj1 = 0 ;
8831 char *kwnames[] = {
8832 (char *) "self",(char *) "location", NULL
8833 };
8834
8835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8837 if (SWIG_arg_fail(1)) SWIG_fail;
8838 {
8839 arg2 = wxString_in_helper(obj1);
8840 if (arg2 == NULL) SWIG_fail;
8841 temp2 = true;
8842 }
8843 {
8844 PyThreadState* __tstate = wxPyBeginAllowThreads();
8845 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8846
8847 wxPyEndAllowThreads(__tstate);
8848 if (PyErr_Occurred()) SWIG_fail;
8849 }
8850 {
8851 resultobj = wxPyMake_wxObject(result, 1);
8852 }
8853 {
8854 if (temp2)
8855 delete arg2;
8856 }
8857 return resultobj;
8858 fail:
8859 {
8860 if (temp2)
8861 delete arg2;
8862 }
8863 return NULL;
8864 }
8865
8866
8867 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8868 PyObject *resultobj;
8869 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8870 wxString *arg2 = 0 ;
8871 int arg3 = (int) 0 ;
8872 wxString result;
8873 bool temp2 = false ;
8874 PyObject * obj0 = 0 ;
8875 PyObject * obj1 = 0 ;
8876 PyObject * obj2 = 0 ;
8877 char *kwnames[] = {
8878 (char *) "self",(char *) "spec",(char *) "flags", NULL
8879 };
8880
8881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8883 if (SWIG_arg_fail(1)) SWIG_fail;
8884 {
8885 arg2 = wxString_in_helper(obj1);
8886 if (arg2 == NULL) SWIG_fail;
8887 temp2 = true;
8888 }
8889 if (obj2) {
8890 {
8891 arg3 = (int)(SWIG_As_int(obj2));
8892 if (SWIG_arg_fail(3)) SWIG_fail;
8893 }
8894 }
8895 {
8896 PyThreadState* __tstate = wxPyBeginAllowThreads();
8897 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8898
8899 wxPyEndAllowThreads(__tstate);
8900 if (PyErr_Occurred()) SWIG_fail;
8901 }
8902 {
8903 #if wxUSE_UNICODE
8904 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8905 #else
8906 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8907 #endif
8908 }
8909 {
8910 if (temp2)
8911 delete arg2;
8912 }
8913 return resultobj;
8914 fail:
8915 {
8916 if (temp2)
8917 delete arg2;
8918 }
8919 return NULL;
8920 }
8921
8922
8923 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8924 PyObject *resultobj;
8925 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8926 wxString result;
8927 PyObject * obj0 = 0 ;
8928 char *kwnames[] = {
8929 (char *) "self", NULL
8930 };
8931
8932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8934 if (SWIG_arg_fail(1)) SWIG_fail;
8935 {
8936 PyThreadState* __tstate = wxPyBeginAllowThreads();
8937 result = (arg1)->FindNext();
8938
8939 wxPyEndAllowThreads(__tstate);
8940 if (PyErr_Occurred()) SWIG_fail;
8941 }
8942 {
8943 #if wxUSE_UNICODE
8944 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8945 #else
8946 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8947 #endif
8948 }
8949 return resultobj;
8950 fail:
8951 return NULL;
8952 }
8953
8954
8955 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8956 PyObject *resultobj;
8957 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8958 PyObject * obj0 = 0 ;
8959 char *kwnames[] = {
8960 (char *) "handler", NULL
8961 };
8962
8963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8965 if (SWIG_arg_fail(1)) SWIG_fail;
8966 {
8967 PyThreadState* __tstate = wxPyBeginAllowThreads();
8968 wxFileSystem::AddHandler(arg1);
8969
8970 wxPyEndAllowThreads(__tstate);
8971 if (PyErr_Occurred()) SWIG_fail;
8972 }
8973 Py_INCREF(Py_None); resultobj = Py_None;
8974 return resultobj;
8975 fail:
8976 return NULL;
8977 }
8978
8979
8980 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
8981 PyObject *resultobj;
8982 char *kwnames[] = {
8983 NULL
8984 };
8985
8986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
8987 {
8988 PyThreadState* __tstate = wxPyBeginAllowThreads();
8989 wxFileSystem::CleanUpHandlers();
8990
8991 wxPyEndAllowThreads(__tstate);
8992 if (PyErr_Occurred()) SWIG_fail;
8993 }
8994 Py_INCREF(Py_None); resultobj = Py_None;
8995 return resultobj;
8996 fail:
8997 return NULL;
8998 }
8999
9000
9001 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9002 PyObject *resultobj;
9003 wxString *arg1 = 0 ;
9004 wxString result;
9005 bool temp1 = false ;
9006 PyObject * obj0 = 0 ;
9007 char *kwnames[] = {
9008 (char *) "filename", NULL
9009 };
9010
9011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9012 {
9013 arg1 = wxString_in_helper(obj0);
9014 if (arg1 == NULL) SWIG_fail;
9015 temp1 = true;
9016 }
9017 {
9018 PyThreadState* __tstate = wxPyBeginAllowThreads();
9019 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9020
9021 wxPyEndAllowThreads(__tstate);
9022 if (PyErr_Occurred()) SWIG_fail;
9023 }
9024 {
9025 #if wxUSE_UNICODE
9026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9027 #else
9028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9029 #endif
9030 }
9031 {
9032 if (temp1)
9033 delete arg1;
9034 }
9035 return resultobj;
9036 fail:
9037 {
9038 if (temp1)
9039 delete arg1;
9040 }
9041 return NULL;
9042 }
9043
9044
9045 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9046 PyObject *resultobj;
9047 wxString *arg1 = 0 ;
9048 wxString result;
9049 bool temp1 = false ;
9050 PyObject * obj0 = 0 ;
9051 char *kwnames[] = {
9052 (char *) "url", NULL
9053 };
9054
9055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9056 {
9057 arg1 = wxString_in_helper(obj0);
9058 if (arg1 == NULL) SWIG_fail;
9059 temp1 = true;
9060 }
9061 {
9062 PyThreadState* __tstate = wxPyBeginAllowThreads();
9063 result = FileSystem_URLToFileName((wxString const &)*arg1);
9064
9065 wxPyEndAllowThreads(__tstate);
9066 if (PyErr_Occurred()) SWIG_fail;
9067 }
9068 {
9069 #if wxUSE_UNICODE
9070 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9071 #else
9072 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9073 #endif
9074 }
9075 {
9076 if (temp1)
9077 delete arg1;
9078 }
9079 return resultobj;
9080 fail:
9081 {
9082 if (temp1)
9083 delete arg1;
9084 }
9085 return NULL;
9086 }
9087
9088
9089 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9090 PyObject *obj;
9091 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9092 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9093 Py_INCREF(obj);
9094 return Py_BuildValue((char *)"");
9095 }
9096 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9097 PyObject *resultobj;
9098 wxInternetFSHandler *result;
9099 char *kwnames[] = {
9100 NULL
9101 };
9102
9103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9104 {
9105 PyThreadState* __tstate = wxPyBeginAllowThreads();
9106 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9107
9108 wxPyEndAllowThreads(__tstate);
9109 if (PyErr_Occurred()) SWIG_fail;
9110 }
9111 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9112 return resultobj;
9113 fail:
9114 return NULL;
9115 }
9116
9117
9118 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9119 PyObject *resultobj;
9120 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9121 wxString *arg2 = 0 ;
9122 bool result;
9123 bool temp2 = false ;
9124 PyObject * obj0 = 0 ;
9125 PyObject * obj1 = 0 ;
9126 char *kwnames[] = {
9127 (char *) "self",(char *) "location", NULL
9128 };
9129
9130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9132 if (SWIG_arg_fail(1)) SWIG_fail;
9133 {
9134 arg2 = wxString_in_helper(obj1);
9135 if (arg2 == NULL) SWIG_fail;
9136 temp2 = true;
9137 }
9138 {
9139 PyThreadState* __tstate = wxPyBeginAllowThreads();
9140 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9141
9142 wxPyEndAllowThreads(__tstate);
9143 if (PyErr_Occurred()) SWIG_fail;
9144 }
9145 {
9146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9147 }
9148 {
9149 if (temp2)
9150 delete arg2;
9151 }
9152 return resultobj;
9153 fail:
9154 {
9155 if (temp2)
9156 delete arg2;
9157 }
9158 return NULL;
9159 }
9160
9161
9162 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9163 PyObject *resultobj;
9164 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9165 wxFileSystem *arg2 = 0 ;
9166 wxString *arg3 = 0 ;
9167 wxFSFile *result;
9168 bool temp3 = false ;
9169 PyObject * obj0 = 0 ;
9170 PyObject * obj1 = 0 ;
9171 PyObject * obj2 = 0 ;
9172 char *kwnames[] = {
9173 (char *) "self",(char *) "fs",(char *) "location", NULL
9174 };
9175
9176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9178 if (SWIG_arg_fail(1)) SWIG_fail;
9179 {
9180 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9181 if (SWIG_arg_fail(2)) SWIG_fail;
9182 if (arg2 == NULL) {
9183 SWIG_null_ref("wxFileSystem");
9184 }
9185 if (SWIG_arg_fail(2)) SWIG_fail;
9186 }
9187 {
9188 arg3 = wxString_in_helper(obj2);
9189 if (arg3 == NULL) SWIG_fail;
9190 temp3 = true;
9191 }
9192 {
9193 PyThreadState* __tstate = wxPyBeginAllowThreads();
9194 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9195
9196 wxPyEndAllowThreads(__tstate);
9197 if (PyErr_Occurred()) SWIG_fail;
9198 }
9199 {
9200 resultobj = wxPyMake_wxObject(result, 1);
9201 }
9202 {
9203 if (temp3)
9204 delete arg3;
9205 }
9206 return resultobj;
9207 fail:
9208 {
9209 if (temp3)
9210 delete arg3;
9211 }
9212 return NULL;
9213 }
9214
9215
9216 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9217 PyObject *obj;
9218 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9219 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9220 Py_INCREF(obj);
9221 return Py_BuildValue((char *)"");
9222 }
9223 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9224 PyObject *resultobj;
9225 wxZipFSHandler *result;
9226 char *kwnames[] = {
9227 NULL
9228 };
9229
9230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9231 {
9232 PyThreadState* __tstate = wxPyBeginAllowThreads();
9233 result = (wxZipFSHandler *)new wxZipFSHandler();
9234
9235 wxPyEndAllowThreads(__tstate);
9236 if (PyErr_Occurred()) SWIG_fail;
9237 }
9238 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9239 return resultobj;
9240 fail:
9241 return NULL;
9242 }
9243
9244
9245 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9246 PyObject *resultobj;
9247 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9248 wxString *arg2 = 0 ;
9249 bool result;
9250 bool temp2 = false ;
9251 PyObject * obj0 = 0 ;
9252 PyObject * obj1 = 0 ;
9253 char *kwnames[] = {
9254 (char *) "self",(char *) "location", NULL
9255 };
9256
9257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9259 if (SWIG_arg_fail(1)) SWIG_fail;
9260 {
9261 arg2 = wxString_in_helper(obj1);
9262 if (arg2 == NULL) SWIG_fail;
9263 temp2 = true;
9264 }
9265 {
9266 PyThreadState* __tstate = wxPyBeginAllowThreads();
9267 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9268
9269 wxPyEndAllowThreads(__tstate);
9270 if (PyErr_Occurred()) SWIG_fail;
9271 }
9272 {
9273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9274 }
9275 {
9276 if (temp2)
9277 delete arg2;
9278 }
9279 return resultobj;
9280 fail:
9281 {
9282 if (temp2)
9283 delete arg2;
9284 }
9285 return NULL;
9286 }
9287
9288
9289 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9290 PyObject *resultobj;
9291 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9292 wxFileSystem *arg2 = 0 ;
9293 wxString *arg3 = 0 ;
9294 wxFSFile *result;
9295 bool temp3 = false ;
9296 PyObject * obj0 = 0 ;
9297 PyObject * obj1 = 0 ;
9298 PyObject * obj2 = 0 ;
9299 char *kwnames[] = {
9300 (char *) "self",(char *) "fs",(char *) "location", NULL
9301 };
9302
9303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9305 if (SWIG_arg_fail(1)) SWIG_fail;
9306 {
9307 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9308 if (SWIG_arg_fail(2)) SWIG_fail;
9309 if (arg2 == NULL) {
9310 SWIG_null_ref("wxFileSystem");
9311 }
9312 if (SWIG_arg_fail(2)) SWIG_fail;
9313 }
9314 {
9315 arg3 = wxString_in_helper(obj2);
9316 if (arg3 == NULL) SWIG_fail;
9317 temp3 = true;
9318 }
9319 {
9320 PyThreadState* __tstate = wxPyBeginAllowThreads();
9321 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9322
9323 wxPyEndAllowThreads(__tstate);
9324 if (PyErr_Occurred()) SWIG_fail;
9325 }
9326 {
9327 resultobj = wxPyMake_wxObject(result, 1);
9328 }
9329 {
9330 if (temp3)
9331 delete arg3;
9332 }
9333 return resultobj;
9334 fail:
9335 {
9336 if (temp3)
9337 delete arg3;
9338 }
9339 return NULL;
9340 }
9341
9342
9343 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9344 PyObject *resultobj;
9345 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9346 wxString *arg2 = 0 ;
9347 int arg3 = (int) 0 ;
9348 wxString result;
9349 bool temp2 = false ;
9350 PyObject * obj0 = 0 ;
9351 PyObject * obj1 = 0 ;
9352 PyObject * obj2 = 0 ;
9353 char *kwnames[] = {
9354 (char *) "self",(char *) "spec",(char *) "flags", NULL
9355 };
9356
9357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9359 if (SWIG_arg_fail(1)) SWIG_fail;
9360 {
9361 arg2 = wxString_in_helper(obj1);
9362 if (arg2 == NULL) SWIG_fail;
9363 temp2 = true;
9364 }
9365 if (obj2) {
9366 {
9367 arg3 = (int)(SWIG_As_int(obj2));
9368 if (SWIG_arg_fail(3)) SWIG_fail;
9369 }
9370 }
9371 {
9372 PyThreadState* __tstate = wxPyBeginAllowThreads();
9373 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9374
9375 wxPyEndAllowThreads(__tstate);
9376 if (PyErr_Occurred()) SWIG_fail;
9377 }
9378 {
9379 #if wxUSE_UNICODE
9380 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9381 #else
9382 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9383 #endif
9384 }
9385 {
9386 if (temp2)
9387 delete arg2;
9388 }
9389 return resultobj;
9390 fail:
9391 {
9392 if (temp2)
9393 delete arg2;
9394 }
9395 return NULL;
9396 }
9397
9398
9399 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9400 PyObject *resultobj;
9401 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9402 wxString result;
9403 PyObject * obj0 = 0 ;
9404 char *kwnames[] = {
9405 (char *) "self", NULL
9406 };
9407
9408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9410 if (SWIG_arg_fail(1)) SWIG_fail;
9411 {
9412 PyThreadState* __tstate = wxPyBeginAllowThreads();
9413 result = (arg1)->FindNext();
9414
9415 wxPyEndAllowThreads(__tstate);
9416 if (PyErr_Occurred()) SWIG_fail;
9417 }
9418 {
9419 #if wxUSE_UNICODE
9420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9421 #else
9422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9423 #endif
9424 }
9425 return resultobj;
9426 fail:
9427 return NULL;
9428 }
9429
9430
9431 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9432 PyObject *obj;
9433 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9434 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9435 Py_INCREF(obj);
9436 return Py_BuildValue((char *)"");
9437 }
9438 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9439 PyObject *resultobj;
9440 wxString *arg1 = 0 ;
9441 wxImage *arg2 = 0 ;
9442 long arg3 ;
9443 bool temp1 = false ;
9444 PyObject * obj0 = 0 ;
9445 PyObject * obj1 = 0 ;
9446 PyObject * obj2 = 0 ;
9447 char *kwnames[] = {
9448 (char *) "filename",(char *) "image",(char *) "type", NULL
9449 };
9450
9451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9452 {
9453 arg1 = wxString_in_helper(obj0);
9454 if (arg1 == NULL) SWIG_fail;
9455 temp1 = true;
9456 }
9457 {
9458 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9459 if (SWIG_arg_fail(2)) SWIG_fail;
9460 if (arg2 == NULL) {
9461 SWIG_null_ref("wxImage");
9462 }
9463 if (SWIG_arg_fail(2)) SWIG_fail;
9464 }
9465 {
9466 arg3 = (long)(SWIG_As_long(obj2));
9467 if (SWIG_arg_fail(3)) SWIG_fail;
9468 }
9469 {
9470 PyThreadState* __tstate = wxPyBeginAllowThreads();
9471 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9472
9473 wxPyEndAllowThreads(__tstate);
9474 if (PyErr_Occurred()) SWIG_fail;
9475 }
9476 Py_INCREF(Py_None); resultobj = Py_None;
9477 {
9478 if (temp1)
9479 delete arg1;
9480 }
9481 return resultobj;
9482 fail:
9483 {
9484 if (temp1)
9485 delete arg1;
9486 }
9487 return NULL;
9488 }
9489
9490
9491 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9492 PyObject *resultobj;
9493 wxString *arg1 = 0 ;
9494 wxBitmap *arg2 = 0 ;
9495 long arg3 ;
9496 bool temp1 = false ;
9497 PyObject * obj0 = 0 ;
9498 PyObject * obj1 = 0 ;
9499 PyObject * obj2 = 0 ;
9500 char *kwnames[] = {
9501 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9502 };
9503
9504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9505 {
9506 arg1 = wxString_in_helper(obj0);
9507 if (arg1 == NULL) SWIG_fail;
9508 temp1 = true;
9509 }
9510 {
9511 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9512 if (SWIG_arg_fail(2)) SWIG_fail;
9513 if (arg2 == NULL) {
9514 SWIG_null_ref("wxBitmap");
9515 }
9516 if (SWIG_arg_fail(2)) SWIG_fail;
9517 }
9518 {
9519 arg3 = (long)(SWIG_As_long(obj2));
9520 if (SWIG_arg_fail(3)) SWIG_fail;
9521 }
9522 {
9523 PyThreadState* __tstate = wxPyBeginAllowThreads();
9524 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9525
9526 wxPyEndAllowThreads(__tstate);
9527 if (PyErr_Occurred()) SWIG_fail;
9528 }
9529 Py_INCREF(Py_None); resultobj = Py_None;
9530 {
9531 if (temp1)
9532 delete arg1;
9533 }
9534 return resultobj;
9535 fail:
9536 {
9537 if (temp1)
9538 delete arg1;
9539 }
9540 return NULL;
9541 }
9542
9543
9544 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9545 PyObject *resultobj;
9546 wxString *arg1 = 0 ;
9547 PyObject *arg2 = (PyObject *) 0 ;
9548 bool temp1 = false ;
9549 PyObject * obj0 = 0 ;
9550 PyObject * obj1 = 0 ;
9551 char *kwnames[] = {
9552 (char *) "filename",(char *) "data", NULL
9553 };
9554
9555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9556 {
9557 arg1 = wxString_in_helper(obj0);
9558 if (arg1 == NULL) SWIG_fail;
9559 temp1 = true;
9560 }
9561 arg2 = obj1;
9562 {
9563 PyThreadState* __tstate = wxPyBeginAllowThreads();
9564 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9565
9566 wxPyEndAllowThreads(__tstate);
9567 if (PyErr_Occurred()) SWIG_fail;
9568 }
9569 Py_INCREF(Py_None); resultobj = Py_None;
9570 {
9571 if (temp1)
9572 delete arg1;
9573 }
9574 return resultobj;
9575 fail:
9576 {
9577 if (temp1)
9578 delete arg1;
9579 }
9580 return NULL;
9581 }
9582
9583
9584 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9585 PyObject *resultobj;
9586 wxMemoryFSHandler *result;
9587 char *kwnames[] = {
9588 NULL
9589 };
9590
9591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9592 {
9593 PyThreadState* __tstate = wxPyBeginAllowThreads();
9594 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9595
9596 wxPyEndAllowThreads(__tstate);
9597 if (PyErr_Occurred()) SWIG_fail;
9598 }
9599 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9600 return resultobj;
9601 fail:
9602 return NULL;
9603 }
9604
9605
9606 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9607 PyObject *resultobj;
9608 wxString *arg1 = 0 ;
9609 bool temp1 = false ;
9610 PyObject * obj0 = 0 ;
9611 char *kwnames[] = {
9612 (char *) "filename", NULL
9613 };
9614
9615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9616 {
9617 arg1 = wxString_in_helper(obj0);
9618 if (arg1 == NULL) SWIG_fail;
9619 temp1 = true;
9620 }
9621 {
9622 PyThreadState* __tstate = wxPyBeginAllowThreads();
9623 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9624
9625 wxPyEndAllowThreads(__tstate);
9626 if (PyErr_Occurred()) SWIG_fail;
9627 }
9628 Py_INCREF(Py_None); resultobj = Py_None;
9629 {
9630 if (temp1)
9631 delete arg1;
9632 }
9633 return resultobj;
9634 fail:
9635 {
9636 if (temp1)
9637 delete arg1;
9638 }
9639 return NULL;
9640 }
9641
9642
9643 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9644 PyObject *resultobj;
9645 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9646 wxString *arg2 = 0 ;
9647 bool result;
9648 bool temp2 = false ;
9649 PyObject * obj0 = 0 ;
9650 PyObject * obj1 = 0 ;
9651 char *kwnames[] = {
9652 (char *) "self",(char *) "location", NULL
9653 };
9654
9655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9657 if (SWIG_arg_fail(1)) SWIG_fail;
9658 {
9659 arg2 = wxString_in_helper(obj1);
9660 if (arg2 == NULL) SWIG_fail;
9661 temp2 = true;
9662 }
9663 {
9664 PyThreadState* __tstate = wxPyBeginAllowThreads();
9665 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9666
9667 wxPyEndAllowThreads(__tstate);
9668 if (PyErr_Occurred()) SWIG_fail;
9669 }
9670 {
9671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9672 }
9673 {
9674 if (temp2)
9675 delete arg2;
9676 }
9677 return resultobj;
9678 fail:
9679 {
9680 if (temp2)
9681 delete arg2;
9682 }
9683 return NULL;
9684 }
9685
9686
9687 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9688 PyObject *resultobj;
9689 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9690 wxFileSystem *arg2 = 0 ;
9691 wxString *arg3 = 0 ;
9692 wxFSFile *result;
9693 bool temp3 = false ;
9694 PyObject * obj0 = 0 ;
9695 PyObject * obj1 = 0 ;
9696 PyObject * obj2 = 0 ;
9697 char *kwnames[] = {
9698 (char *) "self",(char *) "fs",(char *) "location", NULL
9699 };
9700
9701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9703 if (SWIG_arg_fail(1)) SWIG_fail;
9704 {
9705 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9706 if (SWIG_arg_fail(2)) SWIG_fail;
9707 if (arg2 == NULL) {
9708 SWIG_null_ref("wxFileSystem");
9709 }
9710 if (SWIG_arg_fail(2)) SWIG_fail;
9711 }
9712 {
9713 arg3 = wxString_in_helper(obj2);
9714 if (arg3 == NULL) SWIG_fail;
9715 temp3 = true;
9716 }
9717 {
9718 PyThreadState* __tstate = wxPyBeginAllowThreads();
9719 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9720
9721 wxPyEndAllowThreads(__tstate);
9722 if (PyErr_Occurred()) SWIG_fail;
9723 }
9724 {
9725 resultobj = wxPyMake_wxObject(result, 1);
9726 }
9727 {
9728 if (temp3)
9729 delete arg3;
9730 }
9731 return resultobj;
9732 fail:
9733 {
9734 if (temp3)
9735 delete arg3;
9736 }
9737 return NULL;
9738 }
9739
9740
9741 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9742 PyObject *resultobj;
9743 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9744 wxString *arg2 = 0 ;
9745 int arg3 = (int) 0 ;
9746 wxString result;
9747 bool temp2 = false ;
9748 PyObject * obj0 = 0 ;
9749 PyObject * obj1 = 0 ;
9750 PyObject * obj2 = 0 ;
9751 char *kwnames[] = {
9752 (char *) "self",(char *) "spec",(char *) "flags", NULL
9753 };
9754
9755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9757 if (SWIG_arg_fail(1)) SWIG_fail;
9758 {
9759 arg2 = wxString_in_helper(obj1);
9760 if (arg2 == NULL) SWIG_fail;
9761 temp2 = true;
9762 }
9763 if (obj2) {
9764 {
9765 arg3 = (int)(SWIG_As_int(obj2));
9766 if (SWIG_arg_fail(3)) SWIG_fail;
9767 }
9768 }
9769 {
9770 PyThreadState* __tstate = wxPyBeginAllowThreads();
9771 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9772
9773 wxPyEndAllowThreads(__tstate);
9774 if (PyErr_Occurred()) SWIG_fail;
9775 }
9776 {
9777 #if wxUSE_UNICODE
9778 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9779 #else
9780 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9781 #endif
9782 }
9783 {
9784 if (temp2)
9785 delete arg2;
9786 }
9787 return resultobj;
9788 fail:
9789 {
9790 if (temp2)
9791 delete arg2;
9792 }
9793 return NULL;
9794 }
9795
9796
9797 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9798 PyObject *resultobj;
9799 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9800 wxString result;
9801 PyObject * obj0 = 0 ;
9802 char *kwnames[] = {
9803 (char *) "self", NULL
9804 };
9805
9806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9808 if (SWIG_arg_fail(1)) SWIG_fail;
9809 {
9810 PyThreadState* __tstate = wxPyBeginAllowThreads();
9811 result = (arg1)->FindNext();
9812
9813 wxPyEndAllowThreads(__tstate);
9814 if (PyErr_Occurred()) SWIG_fail;
9815 }
9816 {
9817 #if wxUSE_UNICODE
9818 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9819 #else
9820 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9821 #endif
9822 }
9823 return resultobj;
9824 fail:
9825 return NULL;
9826 }
9827
9828
9829 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9830 PyObject *obj;
9831 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9832 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9833 Py_INCREF(obj);
9834 return Py_BuildValue((char *)"");
9835 }
9836 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9837 PyObject *resultobj;
9838 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9839 wxString result;
9840 PyObject * obj0 = 0 ;
9841 char *kwnames[] = {
9842 (char *) "self", NULL
9843 };
9844
9845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9847 if (SWIG_arg_fail(1)) SWIG_fail;
9848 {
9849 PyThreadState* __tstate = wxPyBeginAllowThreads();
9850 result = (arg1)->GetName();
9851
9852 wxPyEndAllowThreads(__tstate);
9853 if (PyErr_Occurred()) SWIG_fail;
9854 }
9855 {
9856 #if wxUSE_UNICODE
9857 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9858 #else
9859 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9860 #endif
9861 }
9862 return resultobj;
9863 fail:
9864 return NULL;
9865 }
9866
9867
9868 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9869 PyObject *resultobj;
9870 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9871 wxString result;
9872 PyObject * obj0 = 0 ;
9873 char *kwnames[] = {
9874 (char *) "self", NULL
9875 };
9876
9877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9879 if (SWIG_arg_fail(1)) SWIG_fail;
9880 {
9881 PyThreadState* __tstate = wxPyBeginAllowThreads();
9882 result = (arg1)->GetExtension();
9883
9884 wxPyEndAllowThreads(__tstate);
9885 if (PyErr_Occurred()) SWIG_fail;
9886 }
9887 {
9888 #if wxUSE_UNICODE
9889 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9890 #else
9891 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9892 #endif
9893 }
9894 return resultobj;
9895 fail:
9896 return NULL;
9897 }
9898
9899
9900 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9901 PyObject *resultobj;
9902 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9903 long result;
9904 PyObject * obj0 = 0 ;
9905 char *kwnames[] = {
9906 (char *) "self", NULL
9907 };
9908
9909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9911 if (SWIG_arg_fail(1)) SWIG_fail;
9912 {
9913 PyThreadState* __tstate = wxPyBeginAllowThreads();
9914 result = (long)(arg1)->GetType();
9915
9916 wxPyEndAllowThreads(__tstate);
9917 if (PyErr_Occurred()) SWIG_fail;
9918 }
9919 {
9920 resultobj = SWIG_From_long((long)(result));
9921 }
9922 return resultobj;
9923 fail:
9924 return NULL;
9925 }
9926
9927
9928 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9929 PyObject *resultobj;
9930 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9931 wxString result;
9932 PyObject * obj0 = 0 ;
9933 char *kwnames[] = {
9934 (char *) "self", NULL
9935 };
9936
9937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9939 if (SWIG_arg_fail(1)) SWIG_fail;
9940 {
9941 PyThreadState* __tstate = wxPyBeginAllowThreads();
9942 result = (arg1)->GetMimeType();
9943
9944 wxPyEndAllowThreads(__tstate);
9945 if (PyErr_Occurred()) SWIG_fail;
9946 }
9947 {
9948 #if wxUSE_UNICODE
9949 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9950 #else
9951 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9952 #endif
9953 }
9954 return resultobj;
9955 fail:
9956 return NULL;
9957 }
9958
9959
9960 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9961 PyObject *resultobj;
9962 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9963 wxString *arg2 = 0 ;
9964 bool result;
9965 bool temp2 = false ;
9966 PyObject * obj0 = 0 ;
9967 PyObject * obj1 = 0 ;
9968 char *kwnames[] = {
9969 (char *) "self",(char *) "name", NULL
9970 };
9971
9972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
9973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9974 if (SWIG_arg_fail(1)) SWIG_fail;
9975 {
9976 arg2 = wxString_in_helper(obj1);
9977 if (arg2 == NULL) SWIG_fail;
9978 temp2 = true;
9979 }
9980 {
9981 PyThreadState* __tstate = wxPyBeginAllowThreads();
9982 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
9983
9984 wxPyEndAllowThreads(__tstate);
9985 if (PyErr_Occurred()) SWIG_fail;
9986 }
9987 {
9988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9989 }
9990 {
9991 if (temp2)
9992 delete arg2;
9993 }
9994 return resultobj;
9995 fail:
9996 {
9997 if (temp2)
9998 delete arg2;
9999 }
10000 return NULL;
10001 }
10002
10003
10004 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10005 PyObject *resultobj;
10006 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10007 wxString *arg2 = 0 ;
10008 bool temp2 = false ;
10009 PyObject * obj0 = 0 ;
10010 PyObject * obj1 = 0 ;
10011 char *kwnames[] = {
10012 (char *) "self",(char *) "name", NULL
10013 };
10014
10015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10017 if (SWIG_arg_fail(1)) SWIG_fail;
10018 {
10019 arg2 = wxString_in_helper(obj1);
10020 if (arg2 == NULL) SWIG_fail;
10021 temp2 = true;
10022 }
10023 {
10024 PyThreadState* __tstate = wxPyBeginAllowThreads();
10025 (arg1)->SetName((wxString const &)*arg2);
10026
10027 wxPyEndAllowThreads(__tstate);
10028 if (PyErr_Occurred()) SWIG_fail;
10029 }
10030 Py_INCREF(Py_None); resultobj = Py_None;
10031 {
10032 if (temp2)
10033 delete arg2;
10034 }
10035 return resultobj;
10036 fail:
10037 {
10038 if (temp2)
10039 delete arg2;
10040 }
10041 return NULL;
10042 }
10043
10044
10045 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10046 PyObject *resultobj;
10047 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10048 wxString *arg2 = 0 ;
10049 bool temp2 = false ;
10050 PyObject * obj0 = 0 ;
10051 PyObject * obj1 = 0 ;
10052 char *kwnames[] = {
10053 (char *) "self",(char *) "extension", NULL
10054 };
10055
10056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10058 if (SWIG_arg_fail(1)) SWIG_fail;
10059 {
10060 arg2 = wxString_in_helper(obj1);
10061 if (arg2 == NULL) SWIG_fail;
10062 temp2 = true;
10063 }
10064 {
10065 PyThreadState* __tstate = wxPyBeginAllowThreads();
10066 (arg1)->SetExtension((wxString const &)*arg2);
10067
10068 wxPyEndAllowThreads(__tstate);
10069 if (PyErr_Occurred()) SWIG_fail;
10070 }
10071 Py_INCREF(Py_None); resultobj = Py_None;
10072 {
10073 if (temp2)
10074 delete arg2;
10075 }
10076 return resultobj;
10077 fail:
10078 {
10079 if (temp2)
10080 delete arg2;
10081 }
10082 return NULL;
10083 }
10084
10085
10086 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10087 PyObject *resultobj;
10088 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10089 long arg2 ;
10090 PyObject * obj0 = 0 ;
10091 PyObject * obj1 = 0 ;
10092 char *kwnames[] = {
10093 (char *) "self",(char *) "type", NULL
10094 };
10095
10096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10098 if (SWIG_arg_fail(1)) SWIG_fail;
10099 {
10100 arg2 = (long)(SWIG_As_long(obj1));
10101 if (SWIG_arg_fail(2)) SWIG_fail;
10102 }
10103 {
10104 PyThreadState* __tstate = wxPyBeginAllowThreads();
10105 (arg1)->SetType(arg2);
10106
10107 wxPyEndAllowThreads(__tstate);
10108 if (PyErr_Occurred()) SWIG_fail;
10109 }
10110 Py_INCREF(Py_None); resultobj = Py_None;
10111 return resultobj;
10112 fail:
10113 return NULL;
10114 }
10115
10116
10117 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10118 PyObject *resultobj;
10119 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10120 wxString *arg2 = 0 ;
10121 bool temp2 = false ;
10122 PyObject * obj0 = 0 ;
10123 PyObject * obj1 = 0 ;
10124 char *kwnames[] = {
10125 (char *) "self",(char *) "mimetype", NULL
10126 };
10127
10128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10130 if (SWIG_arg_fail(1)) SWIG_fail;
10131 {
10132 arg2 = wxString_in_helper(obj1);
10133 if (arg2 == NULL) SWIG_fail;
10134 temp2 = true;
10135 }
10136 {
10137 PyThreadState* __tstate = wxPyBeginAllowThreads();
10138 (arg1)->SetMimeType((wxString const &)*arg2);
10139
10140 wxPyEndAllowThreads(__tstate);
10141 if (PyErr_Occurred()) SWIG_fail;
10142 }
10143 Py_INCREF(Py_None); resultobj = Py_None;
10144 {
10145 if (temp2)
10146 delete arg2;
10147 }
10148 return resultobj;
10149 fail:
10150 {
10151 if (temp2)
10152 delete arg2;
10153 }
10154 return NULL;
10155 }
10156
10157
10158 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10159 PyObject *obj;
10160 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10161 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10162 Py_INCREF(obj);
10163 return Py_BuildValue((char *)"");
10164 }
10165 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10166 PyObject *resultobj;
10167 wxImageHistogram *result;
10168 char *kwnames[] = {
10169 NULL
10170 };
10171
10172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10173 {
10174 PyThreadState* __tstate = wxPyBeginAllowThreads();
10175 result = (wxImageHistogram *)new wxImageHistogram();
10176
10177 wxPyEndAllowThreads(__tstate);
10178 if (PyErr_Occurred()) SWIG_fail;
10179 }
10180 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10181 return resultobj;
10182 fail:
10183 return NULL;
10184 }
10185
10186
10187 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10188 PyObject *resultobj;
10189 unsigned char arg1 ;
10190 unsigned char arg2 ;
10191 unsigned char arg3 ;
10192 unsigned long result;
10193 PyObject * obj0 = 0 ;
10194 PyObject * obj1 = 0 ;
10195 PyObject * obj2 = 0 ;
10196 char *kwnames[] = {
10197 (char *) "r",(char *) "g",(char *) "b", NULL
10198 };
10199
10200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10201 {
10202 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10203 if (SWIG_arg_fail(1)) SWIG_fail;
10204 }
10205 {
10206 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10207 if (SWIG_arg_fail(2)) SWIG_fail;
10208 }
10209 {
10210 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10211 if (SWIG_arg_fail(3)) SWIG_fail;
10212 }
10213 {
10214 PyThreadState* __tstate = wxPyBeginAllowThreads();
10215 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10216
10217 wxPyEndAllowThreads(__tstate);
10218 if (PyErr_Occurred()) SWIG_fail;
10219 }
10220 {
10221 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10222 }
10223 return resultobj;
10224 fail:
10225 return NULL;
10226 }
10227
10228
10229 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10230 PyObject *resultobj;
10231 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10232 unsigned char *arg2 = (unsigned char *) 0 ;
10233 unsigned char *arg3 = (unsigned char *) 0 ;
10234 unsigned char *arg4 = (unsigned char *) 0 ;
10235 unsigned char arg5 = (unsigned char) 1 ;
10236 unsigned char arg6 = (unsigned char) 0 ;
10237 unsigned char arg7 = (unsigned char) 0 ;
10238 bool result;
10239 unsigned char temp2 ;
10240 int res2 = 0 ;
10241 unsigned char temp3 ;
10242 int res3 = 0 ;
10243 unsigned char temp4 ;
10244 int res4 = 0 ;
10245 PyObject * obj0 = 0 ;
10246 PyObject * obj1 = 0 ;
10247 PyObject * obj2 = 0 ;
10248 PyObject * obj3 = 0 ;
10249 char *kwnames[] = {
10250 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10251 };
10252
10253 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10254 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10255 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10258 if (SWIG_arg_fail(1)) SWIG_fail;
10259 if (obj1) {
10260 {
10261 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10262 if (SWIG_arg_fail(5)) SWIG_fail;
10263 }
10264 }
10265 if (obj2) {
10266 {
10267 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10268 if (SWIG_arg_fail(6)) SWIG_fail;
10269 }
10270 }
10271 if (obj3) {
10272 {
10273 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10274 if (SWIG_arg_fail(7)) SWIG_fail;
10275 }
10276 }
10277 {
10278 PyThreadState* __tstate = wxPyBeginAllowThreads();
10279 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10280
10281 wxPyEndAllowThreads(__tstate);
10282 if (PyErr_Occurred()) SWIG_fail;
10283 }
10284 {
10285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10286 }
10287 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10288 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10289 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10290 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10291 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10292 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10293 return resultobj;
10294 fail:
10295 return NULL;
10296 }
10297
10298
10299 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10300 PyObject *obj;
10301 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10302 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10303 Py_INCREF(obj);
10304 return Py_BuildValue((char *)"");
10305 }
10306 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10307 PyObject *resultobj;
10308 wxString *arg1 = 0 ;
10309 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10310 int arg3 = (int) -1 ;
10311 wxImage *result;
10312 bool temp1 = false ;
10313 PyObject * obj0 = 0 ;
10314 PyObject * obj1 = 0 ;
10315 PyObject * obj2 = 0 ;
10316 char *kwnames[] = {
10317 (char *) "name",(char *) "type",(char *) "index", NULL
10318 };
10319
10320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10321 {
10322 arg1 = wxString_in_helper(obj0);
10323 if (arg1 == NULL) SWIG_fail;
10324 temp1 = true;
10325 }
10326 if (obj1) {
10327 {
10328 arg2 = (long)(SWIG_As_long(obj1));
10329 if (SWIG_arg_fail(2)) SWIG_fail;
10330 }
10331 }
10332 if (obj2) {
10333 {
10334 arg3 = (int)(SWIG_As_int(obj2));
10335 if (SWIG_arg_fail(3)) SWIG_fail;
10336 }
10337 }
10338 {
10339 PyThreadState* __tstate = wxPyBeginAllowThreads();
10340 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10341
10342 wxPyEndAllowThreads(__tstate);
10343 if (PyErr_Occurred()) SWIG_fail;
10344 }
10345 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10346 {
10347 if (temp1)
10348 delete arg1;
10349 }
10350 return resultobj;
10351 fail:
10352 {
10353 if (temp1)
10354 delete arg1;
10355 }
10356 return NULL;
10357 }
10358
10359
10360 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10361 PyObject *resultobj;
10362 wxImage *arg1 = (wxImage *) 0 ;
10363 PyObject * obj0 = 0 ;
10364 char *kwnames[] = {
10365 (char *) "self", NULL
10366 };
10367
10368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10370 if (SWIG_arg_fail(1)) SWIG_fail;
10371 {
10372 PyThreadState* __tstate = wxPyBeginAllowThreads();
10373 delete arg1;
10374
10375 wxPyEndAllowThreads(__tstate);
10376 if (PyErr_Occurred()) SWIG_fail;
10377 }
10378 Py_INCREF(Py_None); resultobj = Py_None;
10379 return resultobj;
10380 fail:
10381 return NULL;
10382 }
10383
10384
10385 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10386 PyObject *resultobj;
10387 wxString *arg1 = 0 ;
10388 wxString *arg2 = 0 ;
10389 int arg3 = (int) -1 ;
10390 wxImage *result;
10391 bool temp1 = false ;
10392 bool temp2 = false ;
10393 PyObject * obj0 = 0 ;
10394 PyObject * obj1 = 0 ;
10395 PyObject * obj2 = 0 ;
10396 char *kwnames[] = {
10397 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10398 };
10399
10400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10401 {
10402 arg1 = wxString_in_helper(obj0);
10403 if (arg1 == NULL) SWIG_fail;
10404 temp1 = true;
10405 }
10406 {
10407 arg2 = wxString_in_helper(obj1);
10408 if (arg2 == NULL) SWIG_fail;
10409 temp2 = true;
10410 }
10411 if (obj2) {
10412 {
10413 arg3 = (int)(SWIG_As_int(obj2));
10414 if (SWIG_arg_fail(3)) SWIG_fail;
10415 }
10416 }
10417 {
10418 PyThreadState* __tstate = wxPyBeginAllowThreads();
10419 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10420
10421 wxPyEndAllowThreads(__tstate);
10422 if (PyErr_Occurred()) SWIG_fail;
10423 }
10424 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10425 {
10426 if (temp1)
10427 delete arg1;
10428 }
10429 {
10430 if (temp2)
10431 delete arg2;
10432 }
10433 return resultobj;
10434 fail:
10435 {
10436 if (temp1)
10437 delete arg1;
10438 }
10439 {
10440 if (temp2)
10441 delete arg2;
10442 }
10443 return NULL;
10444 }
10445
10446
10447 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10448 PyObject *resultobj;
10449 wxInputStream *arg1 = 0 ;
10450 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10451 int arg3 = (int) -1 ;
10452 wxImage *result;
10453 wxPyInputStream *temp1 ;
10454 bool created1 ;
10455 PyObject * obj0 = 0 ;
10456 PyObject * obj1 = 0 ;
10457 PyObject * obj2 = 0 ;
10458 char *kwnames[] = {
10459 (char *) "stream",(char *) "type",(char *) "index", NULL
10460 };
10461
10462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10463 {
10464 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10465 arg1 = temp1->m_wxis;
10466 created1 = false;
10467 } else {
10468 PyErr_Clear(); // clear the failure of the wxPyConvert above
10469 arg1 = wxPyCBInputStream_create(obj0, false);
10470 if (arg1 == NULL) {
10471 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10472 SWIG_fail;
10473 }
10474 created1 = true;
10475 }
10476 }
10477 if (obj1) {
10478 {
10479 arg2 = (long)(SWIG_As_long(obj1));
10480 if (SWIG_arg_fail(2)) SWIG_fail;
10481 }
10482 }
10483 if (obj2) {
10484 {
10485 arg3 = (int)(SWIG_As_int(obj2));
10486 if (SWIG_arg_fail(3)) SWIG_fail;
10487 }
10488 }
10489 {
10490 PyThreadState* __tstate = wxPyBeginAllowThreads();
10491 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10492
10493 wxPyEndAllowThreads(__tstate);
10494 if (PyErr_Occurred()) SWIG_fail;
10495 }
10496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10497 {
10498 if (created1)
10499 delete arg1;
10500 }
10501 return resultobj;
10502 fail:
10503 {
10504 if (created1)
10505 delete arg1;
10506 }
10507 return NULL;
10508 }
10509
10510
10511 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10512 PyObject *resultobj;
10513 wxInputStream *arg1 = 0 ;
10514 wxString *arg2 = 0 ;
10515 int arg3 = (int) -1 ;
10516 wxImage *result;
10517 wxPyInputStream *temp1 ;
10518 bool created1 ;
10519 bool temp2 = false ;
10520 PyObject * obj0 = 0 ;
10521 PyObject * obj1 = 0 ;
10522 PyObject * obj2 = 0 ;
10523 char *kwnames[] = {
10524 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10525 };
10526
10527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10528 {
10529 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10530 arg1 = temp1->m_wxis;
10531 created1 = false;
10532 } else {
10533 PyErr_Clear(); // clear the failure of the wxPyConvert above
10534 arg1 = wxPyCBInputStream_create(obj0, false);
10535 if (arg1 == NULL) {
10536 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10537 SWIG_fail;
10538 }
10539 created1 = true;
10540 }
10541 }
10542 {
10543 arg2 = wxString_in_helper(obj1);
10544 if (arg2 == NULL) SWIG_fail;
10545 temp2 = true;
10546 }
10547 if (obj2) {
10548 {
10549 arg3 = (int)(SWIG_As_int(obj2));
10550 if (SWIG_arg_fail(3)) SWIG_fail;
10551 }
10552 }
10553 {
10554 PyThreadState* __tstate = wxPyBeginAllowThreads();
10555 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10556
10557 wxPyEndAllowThreads(__tstate);
10558 if (PyErr_Occurred()) SWIG_fail;
10559 }
10560 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10561 {
10562 if (created1)
10563 delete arg1;
10564 }
10565 {
10566 if (temp2)
10567 delete arg2;
10568 }
10569 return resultobj;
10570 fail:
10571 {
10572 if (created1)
10573 delete arg1;
10574 }
10575 {
10576 if (temp2)
10577 delete arg2;
10578 }
10579 return NULL;
10580 }
10581
10582
10583 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10584 PyObject *resultobj;
10585 int arg1 = (int) 0 ;
10586 int arg2 = (int) 0 ;
10587 bool arg3 = (bool) true ;
10588 wxImage *result;
10589 PyObject * obj0 = 0 ;
10590 PyObject * obj1 = 0 ;
10591 PyObject * obj2 = 0 ;
10592 char *kwnames[] = {
10593 (char *) "width",(char *) "height",(char *) "clear", NULL
10594 };
10595
10596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10597 if (obj0) {
10598 {
10599 arg1 = (int)(SWIG_As_int(obj0));
10600 if (SWIG_arg_fail(1)) SWIG_fail;
10601 }
10602 }
10603 if (obj1) {
10604 {
10605 arg2 = (int)(SWIG_As_int(obj1));
10606 if (SWIG_arg_fail(2)) SWIG_fail;
10607 }
10608 }
10609 if (obj2) {
10610 {
10611 arg3 = (bool)(SWIG_As_bool(obj2));
10612 if (SWIG_arg_fail(3)) SWIG_fail;
10613 }
10614 }
10615 {
10616 PyThreadState* __tstate = wxPyBeginAllowThreads();
10617 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10618
10619 wxPyEndAllowThreads(__tstate);
10620 if (PyErr_Occurred()) SWIG_fail;
10621 }
10622 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10623 return resultobj;
10624 fail:
10625 return NULL;
10626 }
10627
10628
10629 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10630 PyObject *resultobj;
10631 wxBitmap *arg1 = 0 ;
10632 wxImage *result;
10633 PyObject * obj0 = 0 ;
10634 char *kwnames[] = {
10635 (char *) "bitmap", NULL
10636 };
10637
10638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10639 {
10640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10641 if (SWIG_arg_fail(1)) SWIG_fail;
10642 if (arg1 == NULL) {
10643 SWIG_null_ref("wxBitmap");
10644 }
10645 if (SWIG_arg_fail(1)) SWIG_fail;
10646 }
10647 {
10648 if (!wxPyCheckForApp()) SWIG_fail;
10649 PyThreadState* __tstate = wxPyBeginAllowThreads();
10650 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10651
10652 wxPyEndAllowThreads(__tstate);
10653 if (PyErr_Occurred()) SWIG_fail;
10654 }
10655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10656 return resultobj;
10657 fail:
10658 return NULL;
10659 }
10660
10661
10662 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10663 PyObject *resultobj;
10664 int arg1 ;
10665 int arg2 ;
10666 unsigned char *arg3 = (unsigned char *) 0 ;
10667 wxImage *result;
10668 PyObject * obj0 = 0 ;
10669 PyObject * obj1 = 0 ;
10670 PyObject * obj2 = 0 ;
10671 char *kwnames[] = {
10672 (char *) "width",(char *) "height",(char *) "data", NULL
10673 };
10674
10675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10676 {
10677 arg1 = (int)(SWIG_As_int(obj0));
10678 if (SWIG_arg_fail(1)) SWIG_fail;
10679 }
10680 {
10681 arg2 = (int)(SWIG_As_int(obj1));
10682 if (SWIG_arg_fail(2)) SWIG_fail;
10683 }
10684 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10685 if (SWIG_arg_fail(3)) SWIG_fail;
10686 {
10687 PyThreadState* __tstate = wxPyBeginAllowThreads();
10688 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10689
10690 wxPyEndAllowThreads(__tstate);
10691 if (PyErr_Occurred()) SWIG_fail;
10692 }
10693 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10694 return resultobj;
10695 fail:
10696 return NULL;
10697 }
10698
10699
10700 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10701 PyObject *resultobj;
10702 int arg1 ;
10703 int arg2 ;
10704 unsigned char *arg3 = (unsigned char *) 0 ;
10705 unsigned char *arg4 = (unsigned char *) 0 ;
10706 wxImage *result;
10707 PyObject * obj0 = 0 ;
10708 PyObject * obj1 = 0 ;
10709 PyObject * obj2 = 0 ;
10710 PyObject * obj3 = 0 ;
10711 char *kwnames[] = {
10712 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10713 };
10714
10715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10716 {
10717 arg1 = (int)(SWIG_As_int(obj0));
10718 if (SWIG_arg_fail(1)) SWIG_fail;
10719 }
10720 {
10721 arg2 = (int)(SWIG_As_int(obj1));
10722 if (SWIG_arg_fail(2)) SWIG_fail;
10723 }
10724 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10725 if (SWIG_arg_fail(3)) SWIG_fail;
10726 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10727 if (SWIG_arg_fail(4)) SWIG_fail;
10728 {
10729 PyThreadState* __tstate = wxPyBeginAllowThreads();
10730 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10731
10732 wxPyEndAllowThreads(__tstate);
10733 if (PyErr_Occurred()) SWIG_fail;
10734 }
10735 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10736 return resultobj;
10737 fail:
10738 return NULL;
10739 }
10740
10741
10742 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10743 PyObject *resultobj;
10744 wxImage *arg1 = (wxImage *) 0 ;
10745 int arg2 ;
10746 int arg3 ;
10747 PyObject * obj0 = 0 ;
10748 PyObject * obj1 = 0 ;
10749 PyObject * obj2 = 0 ;
10750 char *kwnames[] = {
10751 (char *) "self",(char *) "width",(char *) "height", NULL
10752 };
10753
10754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10756 if (SWIG_arg_fail(1)) SWIG_fail;
10757 {
10758 arg2 = (int)(SWIG_As_int(obj1));
10759 if (SWIG_arg_fail(2)) SWIG_fail;
10760 }
10761 {
10762 arg3 = (int)(SWIG_As_int(obj2));
10763 if (SWIG_arg_fail(3)) SWIG_fail;
10764 }
10765 {
10766 PyThreadState* __tstate = wxPyBeginAllowThreads();
10767 (arg1)->Create(arg2,arg3);
10768
10769 wxPyEndAllowThreads(__tstate);
10770 if (PyErr_Occurred()) SWIG_fail;
10771 }
10772 Py_INCREF(Py_None); resultobj = Py_None;
10773 return resultobj;
10774 fail:
10775 return NULL;
10776 }
10777
10778
10779 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10780 PyObject *resultobj;
10781 wxImage *arg1 = (wxImage *) 0 ;
10782 PyObject * obj0 = 0 ;
10783 char *kwnames[] = {
10784 (char *) "self", NULL
10785 };
10786
10787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10789 if (SWIG_arg_fail(1)) SWIG_fail;
10790 {
10791 PyThreadState* __tstate = wxPyBeginAllowThreads();
10792 (arg1)->Destroy();
10793
10794 wxPyEndAllowThreads(__tstate);
10795 if (PyErr_Occurred()) SWIG_fail;
10796 }
10797 Py_INCREF(Py_None); resultobj = Py_None;
10798 return resultobj;
10799 fail:
10800 return NULL;
10801 }
10802
10803
10804 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10805 PyObject *resultobj;
10806 wxImage *arg1 = (wxImage *) 0 ;
10807 int arg2 ;
10808 int arg3 ;
10809 SwigValueWrapper<wxImage > result;
10810 PyObject * obj0 = 0 ;
10811 PyObject * obj1 = 0 ;
10812 PyObject * obj2 = 0 ;
10813 char *kwnames[] = {
10814 (char *) "self",(char *) "width",(char *) "height", NULL
10815 };
10816
10817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10819 if (SWIG_arg_fail(1)) SWIG_fail;
10820 {
10821 arg2 = (int)(SWIG_As_int(obj1));
10822 if (SWIG_arg_fail(2)) SWIG_fail;
10823 }
10824 {
10825 arg3 = (int)(SWIG_As_int(obj2));
10826 if (SWIG_arg_fail(3)) SWIG_fail;
10827 }
10828 {
10829 PyThreadState* __tstate = wxPyBeginAllowThreads();
10830 result = (arg1)->Scale(arg2,arg3);
10831
10832 wxPyEndAllowThreads(__tstate);
10833 if (PyErr_Occurred()) SWIG_fail;
10834 }
10835 {
10836 wxImage * resultptr;
10837 resultptr = new wxImage((wxImage &)(result));
10838 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10839 }
10840 return resultobj;
10841 fail:
10842 return NULL;
10843 }
10844
10845
10846 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10847 PyObject *resultobj;
10848 wxImage *arg1 = (wxImage *) 0 ;
10849 int arg2 ;
10850 int arg3 ;
10851 SwigValueWrapper<wxImage > result;
10852 PyObject * obj0 = 0 ;
10853 PyObject * obj1 = 0 ;
10854 PyObject * obj2 = 0 ;
10855 char *kwnames[] = {
10856 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10857 };
10858
10859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10861 if (SWIG_arg_fail(1)) SWIG_fail;
10862 {
10863 arg2 = (int)(SWIG_As_int(obj1));
10864 if (SWIG_arg_fail(2)) SWIG_fail;
10865 }
10866 {
10867 arg3 = (int)(SWIG_As_int(obj2));
10868 if (SWIG_arg_fail(3)) SWIG_fail;
10869 }
10870 {
10871 PyThreadState* __tstate = wxPyBeginAllowThreads();
10872 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10873
10874 wxPyEndAllowThreads(__tstate);
10875 if (PyErr_Occurred()) SWIG_fail;
10876 }
10877 {
10878 wxImage * resultptr;
10879 resultptr = new wxImage((wxImage &)(result));
10880 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10881 }
10882 return resultobj;
10883 fail:
10884 return NULL;
10885 }
10886
10887
10888 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10889 PyObject *resultobj;
10890 wxImage *arg1 = (wxImage *) 0 ;
10891 int arg2 ;
10892 int arg3 ;
10893 wxImage *result;
10894 PyObject * obj0 = 0 ;
10895 PyObject * obj1 = 0 ;
10896 PyObject * obj2 = 0 ;
10897 char *kwnames[] = {
10898 (char *) "self",(char *) "width",(char *) "height", NULL
10899 };
10900
10901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10903 if (SWIG_arg_fail(1)) SWIG_fail;
10904 {
10905 arg2 = (int)(SWIG_As_int(obj1));
10906 if (SWIG_arg_fail(2)) SWIG_fail;
10907 }
10908 {
10909 arg3 = (int)(SWIG_As_int(obj2));
10910 if (SWIG_arg_fail(3)) SWIG_fail;
10911 }
10912 {
10913 PyThreadState* __tstate = wxPyBeginAllowThreads();
10914 {
10915 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10916 result = (wxImage *) &_result_ref;
10917 }
10918
10919 wxPyEndAllowThreads(__tstate);
10920 if (PyErr_Occurred()) SWIG_fail;
10921 }
10922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10923 return resultobj;
10924 fail:
10925 return NULL;
10926 }
10927
10928
10929 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10930 PyObject *resultobj;
10931 wxImage *arg1 = (wxImage *) 0 ;
10932 int arg2 ;
10933 int arg3 ;
10934 unsigned char arg4 ;
10935 unsigned char arg5 ;
10936 unsigned char arg6 ;
10937 PyObject * obj0 = 0 ;
10938 PyObject * obj1 = 0 ;
10939 PyObject * obj2 = 0 ;
10940 PyObject * obj3 = 0 ;
10941 PyObject * obj4 = 0 ;
10942 PyObject * obj5 = 0 ;
10943 char *kwnames[] = {
10944 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
10945 };
10946
10947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10949 if (SWIG_arg_fail(1)) SWIG_fail;
10950 {
10951 arg2 = (int)(SWIG_As_int(obj1));
10952 if (SWIG_arg_fail(2)) SWIG_fail;
10953 }
10954 {
10955 arg3 = (int)(SWIG_As_int(obj2));
10956 if (SWIG_arg_fail(3)) SWIG_fail;
10957 }
10958 {
10959 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10960 if (SWIG_arg_fail(4)) SWIG_fail;
10961 }
10962 {
10963 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
10964 if (SWIG_arg_fail(5)) SWIG_fail;
10965 }
10966 {
10967 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
10968 if (SWIG_arg_fail(6)) SWIG_fail;
10969 }
10970 {
10971 PyThreadState* __tstate = wxPyBeginAllowThreads();
10972 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
10973
10974 wxPyEndAllowThreads(__tstate);
10975 if (PyErr_Occurred()) SWIG_fail;
10976 }
10977 Py_INCREF(Py_None); resultobj = Py_None;
10978 return resultobj;
10979 fail:
10980 return NULL;
10981 }
10982
10983
10984 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
10985 PyObject *resultobj;
10986 wxImage *arg1 = (wxImage *) 0 ;
10987 int arg2 ;
10988 int arg3 ;
10989 unsigned char result;
10990 PyObject * obj0 = 0 ;
10991 PyObject * obj1 = 0 ;
10992 PyObject * obj2 = 0 ;
10993 char *kwnames[] = {
10994 (char *) "self",(char *) "x",(char *) "y", NULL
10995 };
10996
10997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
10998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10999 if (SWIG_arg_fail(1)) SWIG_fail;
11000 {
11001 arg2 = (int)(SWIG_As_int(obj1));
11002 if (SWIG_arg_fail(2)) SWIG_fail;
11003 }
11004 {
11005 arg3 = (int)(SWIG_As_int(obj2));
11006 if (SWIG_arg_fail(3)) SWIG_fail;
11007 }
11008 {
11009 PyThreadState* __tstate = wxPyBeginAllowThreads();
11010 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11011
11012 wxPyEndAllowThreads(__tstate);
11013 if (PyErr_Occurred()) SWIG_fail;
11014 }
11015 {
11016 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11017 }
11018 return resultobj;
11019 fail:
11020 return NULL;
11021 }
11022
11023
11024 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11025 PyObject *resultobj;
11026 wxImage *arg1 = (wxImage *) 0 ;
11027 int arg2 ;
11028 int arg3 ;
11029 unsigned char result;
11030 PyObject * obj0 = 0 ;
11031 PyObject * obj1 = 0 ;
11032 PyObject * obj2 = 0 ;
11033 char *kwnames[] = {
11034 (char *) "self",(char *) "x",(char *) "y", NULL
11035 };
11036
11037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11039 if (SWIG_arg_fail(1)) SWIG_fail;
11040 {
11041 arg2 = (int)(SWIG_As_int(obj1));
11042 if (SWIG_arg_fail(2)) SWIG_fail;
11043 }
11044 {
11045 arg3 = (int)(SWIG_As_int(obj2));
11046 if (SWIG_arg_fail(3)) SWIG_fail;
11047 }
11048 {
11049 PyThreadState* __tstate = wxPyBeginAllowThreads();
11050 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11051
11052 wxPyEndAllowThreads(__tstate);
11053 if (PyErr_Occurred()) SWIG_fail;
11054 }
11055 {
11056 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11057 }
11058 return resultobj;
11059 fail:
11060 return NULL;
11061 }
11062
11063
11064 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11065 PyObject *resultobj;
11066 wxImage *arg1 = (wxImage *) 0 ;
11067 int arg2 ;
11068 int arg3 ;
11069 unsigned char result;
11070 PyObject * obj0 = 0 ;
11071 PyObject * obj1 = 0 ;
11072 PyObject * obj2 = 0 ;
11073 char *kwnames[] = {
11074 (char *) "self",(char *) "x",(char *) "y", NULL
11075 };
11076
11077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11079 if (SWIG_arg_fail(1)) SWIG_fail;
11080 {
11081 arg2 = (int)(SWIG_As_int(obj1));
11082 if (SWIG_arg_fail(2)) SWIG_fail;
11083 }
11084 {
11085 arg3 = (int)(SWIG_As_int(obj2));
11086 if (SWIG_arg_fail(3)) SWIG_fail;
11087 }
11088 {
11089 PyThreadState* __tstate = wxPyBeginAllowThreads();
11090 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11091
11092 wxPyEndAllowThreads(__tstate);
11093 if (PyErr_Occurred()) SWIG_fail;
11094 }
11095 {
11096 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11097 }
11098 return resultobj;
11099 fail:
11100 return NULL;
11101 }
11102
11103
11104 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11105 PyObject *resultobj;
11106 wxImage *arg1 = (wxImage *) 0 ;
11107 int arg2 ;
11108 int arg3 ;
11109 unsigned char arg4 ;
11110 PyObject * obj0 = 0 ;
11111 PyObject * obj1 = 0 ;
11112 PyObject * obj2 = 0 ;
11113 PyObject * obj3 = 0 ;
11114 char *kwnames[] = {
11115 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11116 };
11117
11118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11120 if (SWIG_arg_fail(1)) SWIG_fail;
11121 {
11122 arg2 = (int)(SWIG_As_int(obj1));
11123 if (SWIG_arg_fail(2)) SWIG_fail;
11124 }
11125 {
11126 arg3 = (int)(SWIG_As_int(obj2));
11127 if (SWIG_arg_fail(3)) SWIG_fail;
11128 }
11129 {
11130 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11131 if (SWIG_arg_fail(4)) SWIG_fail;
11132 }
11133 {
11134 PyThreadState* __tstate = wxPyBeginAllowThreads();
11135 (arg1)->SetAlpha(arg2,arg3,arg4);
11136
11137 wxPyEndAllowThreads(__tstate);
11138 if (PyErr_Occurred()) SWIG_fail;
11139 }
11140 Py_INCREF(Py_None); resultobj = Py_None;
11141 return resultobj;
11142 fail:
11143 return NULL;
11144 }
11145
11146
11147 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11148 PyObject *resultobj;
11149 wxImage *arg1 = (wxImage *) 0 ;
11150 int arg2 ;
11151 int arg3 ;
11152 unsigned char result;
11153 PyObject * obj0 = 0 ;
11154 PyObject * obj1 = 0 ;
11155 PyObject * obj2 = 0 ;
11156 char *kwnames[] = {
11157 (char *) "self",(char *) "x",(char *) "y", NULL
11158 };
11159
11160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11162 if (SWIG_arg_fail(1)) SWIG_fail;
11163 {
11164 arg2 = (int)(SWIG_As_int(obj1));
11165 if (SWIG_arg_fail(2)) SWIG_fail;
11166 }
11167 {
11168 arg3 = (int)(SWIG_As_int(obj2));
11169 if (SWIG_arg_fail(3)) SWIG_fail;
11170 }
11171 {
11172 PyThreadState* __tstate = wxPyBeginAllowThreads();
11173 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11174
11175 wxPyEndAllowThreads(__tstate);
11176 if (PyErr_Occurred()) SWIG_fail;
11177 }
11178 {
11179 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11180 }
11181 return resultobj;
11182 fail:
11183 return NULL;
11184 }
11185
11186
11187 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11188 PyObject *resultobj;
11189 wxImage *arg1 = (wxImage *) 0 ;
11190 bool result;
11191 PyObject * obj0 = 0 ;
11192 char *kwnames[] = {
11193 (char *) "self", NULL
11194 };
11195
11196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11198 if (SWIG_arg_fail(1)) SWIG_fail;
11199 {
11200 PyThreadState* __tstate = wxPyBeginAllowThreads();
11201 result = (bool)(arg1)->HasAlpha();
11202
11203 wxPyEndAllowThreads(__tstate);
11204 if (PyErr_Occurred()) SWIG_fail;
11205 }
11206 {
11207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11208 }
11209 return resultobj;
11210 fail:
11211 return NULL;
11212 }
11213
11214
11215 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11216 PyObject *resultobj;
11217 wxImage *arg1 = (wxImage *) 0 ;
11218 PyObject * obj0 = 0 ;
11219 char *kwnames[] = {
11220 (char *) "self", NULL
11221 };
11222
11223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11225 if (SWIG_arg_fail(1)) SWIG_fail;
11226 {
11227 PyThreadState* __tstate = wxPyBeginAllowThreads();
11228 (arg1)->InitAlpha();
11229
11230 wxPyEndAllowThreads(__tstate);
11231 if (PyErr_Occurred()) SWIG_fail;
11232 }
11233 Py_INCREF(Py_None); resultobj = Py_None;
11234 return resultobj;
11235 fail:
11236 return NULL;
11237 }
11238
11239
11240 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11241 PyObject *resultobj;
11242 wxImage *arg1 = (wxImage *) 0 ;
11243 byte *arg2 = (byte *) 0 ;
11244 byte *arg3 = (byte *) 0 ;
11245 byte *arg4 = (byte *) 0 ;
11246 byte arg5 = (byte) 0 ;
11247 byte arg6 = (byte) 0 ;
11248 byte arg7 = (byte) 0 ;
11249 bool result;
11250 byte temp2 ;
11251 int res2 = 0 ;
11252 byte temp3 ;
11253 int res3 = 0 ;
11254 byte temp4 ;
11255 int res4 = 0 ;
11256 PyObject * obj0 = 0 ;
11257 PyObject * obj1 = 0 ;
11258 PyObject * obj2 = 0 ;
11259 PyObject * obj3 = 0 ;
11260 char *kwnames[] = {
11261 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11262 };
11263
11264 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11265 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11266 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11269 if (SWIG_arg_fail(1)) SWIG_fail;
11270 if (obj1) {
11271 {
11272 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11273 if (SWIG_arg_fail(5)) SWIG_fail;
11274 }
11275 }
11276 if (obj2) {
11277 {
11278 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11279 if (SWIG_arg_fail(6)) SWIG_fail;
11280 }
11281 }
11282 if (obj3) {
11283 {
11284 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11285 if (SWIG_arg_fail(7)) SWIG_fail;
11286 }
11287 }
11288 {
11289 PyThreadState* __tstate = wxPyBeginAllowThreads();
11290 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11291
11292 wxPyEndAllowThreads(__tstate);
11293 if (PyErr_Occurred()) SWIG_fail;
11294 }
11295 {
11296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11297 }
11298 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11299 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11300 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11301 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11302 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11303 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11304 return resultobj;
11305 fail:
11306 return NULL;
11307 }
11308
11309
11310 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11311 PyObject *resultobj;
11312 wxImage *arg1 = (wxImage *) 0 ;
11313 byte arg2 = (byte) 128 ;
11314 bool result;
11315 PyObject * obj0 = 0 ;
11316 PyObject * obj1 = 0 ;
11317 char *kwnames[] = {
11318 (char *) "self",(char *) "threshold", NULL
11319 };
11320
11321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11323 if (SWIG_arg_fail(1)) SWIG_fail;
11324 if (obj1) {
11325 {
11326 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11327 if (SWIG_arg_fail(2)) SWIG_fail;
11328 }
11329 }
11330 {
11331 PyThreadState* __tstate = wxPyBeginAllowThreads();
11332 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11333
11334 wxPyEndAllowThreads(__tstate);
11335 if (PyErr_Occurred()) SWIG_fail;
11336 }
11337 {
11338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11339 }
11340 return resultobj;
11341 fail:
11342 return NULL;
11343 }
11344
11345
11346 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11347 PyObject *resultobj;
11348 wxImage *arg1 = (wxImage *) 0 ;
11349 unsigned char arg2 ;
11350 unsigned char arg3 ;
11351 unsigned char arg4 ;
11352 bool result;
11353 PyObject * obj0 = 0 ;
11354 PyObject * obj1 = 0 ;
11355 PyObject * obj2 = 0 ;
11356 PyObject * obj3 = 0 ;
11357 char *kwnames[] = {
11358 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11359 };
11360
11361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11363 if (SWIG_arg_fail(1)) SWIG_fail;
11364 {
11365 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11366 if (SWIG_arg_fail(2)) SWIG_fail;
11367 }
11368 {
11369 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11370 if (SWIG_arg_fail(3)) SWIG_fail;
11371 }
11372 {
11373 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11374 if (SWIG_arg_fail(4)) SWIG_fail;
11375 }
11376 {
11377 PyThreadState* __tstate = wxPyBeginAllowThreads();
11378 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11379
11380 wxPyEndAllowThreads(__tstate);
11381 if (PyErr_Occurred()) SWIG_fail;
11382 }
11383 {
11384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11385 }
11386 return resultobj;
11387 fail:
11388 return NULL;
11389 }
11390
11391
11392 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11393 PyObject *resultobj;
11394 wxImage *arg1 = (wxImage *) 0 ;
11395 wxImage *arg2 = 0 ;
11396 byte arg3 ;
11397 byte arg4 ;
11398 byte arg5 ;
11399 bool result;
11400 PyObject * obj0 = 0 ;
11401 PyObject * obj1 = 0 ;
11402 PyObject * obj2 = 0 ;
11403 PyObject * obj3 = 0 ;
11404 PyObject * obj4 = 0 ;
11405 char *kwnames[] = {
11406 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11407 };
11408
11409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11411 if (SWIG_arg_fail(1)) SWIG_fail;
11412 {
11413 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11414 if (SWIG_arg_fail(2)) SWIG_fail;
11415 if (arg2 == NULL) {
11416 SWIG_null_ref("wxImage");
11417 }
11418 if (SWIG_arg_fail(2)) SWIG_fail;
11419 }
11420 {
11421 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11422 if (SWIG_arg_fail(3)) SWIG_fail;
11423 }
11424 {
11425 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11426 if (SWIG_arg_fail(4)) SWIG_fail;
11427 }
11428 {
11429 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11430 if (SWIG_arg_fail(5)) SWIG_fail;
11431 }
11432 {
11433 PyThreadState* __tstate = wxPyBeginAllowThreads();
11434 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11435
11436 wxPyEndAllowThreads(__tstate);
11437 if (PyErr_Occurred()) SWIG_fail;
11438 }
11439 {
11440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11441 }
11442 return resultobj;
11443 fail:
11444 return NULL;
11445 }
11446
11447
11448 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11449 PyObject *resultobj;
11450 wxString *arg1 = 0 ;
11451 bool result;
11452 bool temp1 = false ;
11453 PyObject * obj0 = 0 ;
11454 char *kwnames[] = {
11455 (char *) "name", NULL
11456 };
11457
11458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11459 {
11460 arg1 = wxString_in_helper(obj0);
11461 if (arg1 == NULL) SWIG_fail;
11462 temp1 = true;
11463 }
11464 {
11465 PyThreadState* __tstate = wxPyBeginAllowThreads();
11466 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11467
11468 wxPyEndAllowThreads(__tstate);
11469 if (PyErr_Occurred()) SWIG_fail;
11470 }
11471 {
11472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11473 }
11474 {
11475 if (temp1)
11476 delete arg1;
11477 }
11478 return resultobj;
11479 fail:
11480 {
11481 if (temp1)
11482 delete arg1;
11483 }
11484 return NULL;
11485 }
11486
11487
11488 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11489 PyObject *resultobj;
11490 wxString *arg1 = 0 ;
11491 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11492 int result;
11493 bool temp1 = false ;
11494 PyObject * obj0 = 0 ;
11495 PyObject * obj1 = 0 ;
11496 char *kwnames[] = {
11497 (char *) "name",(char *) "type", NULL
11498 };
11499
11500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11501 {
11502 arg1 = wxString_in_helper(obj0);
11503 if (arg1 == NULL) SWIG_fail;
11504 temp1 = true;
11505 }
11506 if (obj1) {
11507 {
11508 arg2 = (long)(SWIG_As_long(obj1));
11509 if (SWIG_arg_fail(2)) SWIG_fail;
11510 }
11511 }
11512 {
11513 PyThreadState* __tstate = wxPyBeginAllowThreads();
11514 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11515
11516 wxPyEndAllowThreads(__tstate);
11517 if (PyErr_Occurred()) SWIG_fail;
11518 }
11519 {
11520 resultobj = SWIG_From_int((int)(result));
11521 }
11522 {
11523 if (temp1)
11524 delete arg1;
11525 }
11526 return resultobj;
11527 fail:
11528 {
11529 if (temp1)
11530 delete arg1;
11531 }
11532 return NULL;
11533 }
11534
11535
11536 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11537 PyObject *resultobj;
11538 wxImage *arg1 = (wxImage *) 0 ;
11539 wxString *arg2 = 0 ;
11540 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11541 int arg4 = (int) -1 ;
11542 bool result;
11543 bool temp2 = false ;
11544 PyObject * obj0 = 0 ;
11545 PyObject * obj1 = 0 ;
11546 PyObject * obj2 = 0 ;
11547 PyObject * obj3 = 0 ;
11548 char *kwnames[] = {
11549 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11550 };
11551
11552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11554 if (SWIG_arg_fail(1)) SWIG_fail;
11555 {
11556 arg2 = wxString_in_helper(obj1);
11557 if (arg2 == NULL) SWIG_fail;
11558 temp2 = true;
11559 }
11560 if (obj2) {
11561 {
11562 arg3 = (long)(SWIG_As_long(obj2));
11563 if (SWIG_arg_fail(3)) SWIG_fail;
11564 }
11565 }
11566 if (obj3) {
11567 {
11568 arg4 = (int)(SWIG_As_int(obj3));
11569 if (SWIG_arg_fail(4)) SWIG_fail;
11570 }
11571 }
11572 {
11573 PyThreadState* __tstate = wxPyBeginAllowThreads();
11574 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11575
11576 wxPyEndAllowThreads(__tstate);
11577 if (PyErr_Occurred()) SWIG_fail;
11578 }
11579 {
11580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11581 }
11582 {
11583 if (temp2)
11584 delete arg2;
11585 }
11586 return resultobj;
11587 fail:
11588 {
11589 if (temp2)
11590 delete arg2;
11591 }
11592 return NULL;
11593 }
11594
11595
11596 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11597 PyObject *resultobj;
11598 wxImage *arg1 = (wxImage *) 0 ;
11599 wxString *arg2 = 0 ;
11600 wxString *arg3 = 0 ;
11601 int arg4 = (int) -1 ;
11602 bool result;
11603 bool temp2 = false ;
11604 bool temp3 = false ;
11605 PyObject * obj0 = 0 ;
11606 PyObject * obj1 = 0 ;
11607 PyObject * obj2 = 0 ;
11608 PyObject * obj3 = 0 ;
11609 char *kwnames[] = {
11610 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11611 };
11612
11613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11615 if (SWIG_arg_fail(1)) SWIG_fail;
11616 {
11617 arg2 = wxString_in_helper(obj1);
11618 if (arg2 == NULL) SWIG_fail;
11619 temp2 = true;
11620 }
11621 {
11622 arg3 = wxString_in_helper(obj2);
11623 if (arg3 == NULL) SWIG_fail;
11624 temp3 = true;
11625 }
11626 if (obj3) {
11627 {
11628 arg4 = (int)(SWIG_As_int(obj3));
11629 if (SWIG_arg_fail(4)) SWIG_fail;
11630 }
11631 }
11632 {
11633 PyThreadState* __tstate = wxPyBeginAllowThreads();
11634 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11635
11636 wxPyEndAllowThreads(__tstate);
11637 if (PyErr_Occurred()) SWIG_fail;
11638 }
11639 {
11640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11641 }
11642 {
11643 if (temp2)
11644 delete arg2;
11645 }
11646 {
11647 if (temp3)
11648 delete arg3;
11649 }
11650 return resultobj;
11651 fail:
11652 {
11653 if (temp2)
11654 delete arg2;
11655 }
11656 {
11657 if (temp3)
11658 delete arg3;
11659 }
11660 return NULL;
11661 }
11662
11663
11664 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11665 PyObject *resultobj;
11666 wxImage *arg1 = (wxImage *) 0 ;
11667 wxString *arg2 = 0 ;
11668 int arg3 ;
11669 bool result;
11670 bool temp2 = false ;
11671 PyObject * obj0 = 0 ;
11672 PyObject * obj1 = 0 ;
11673 PyObject * obj2 = 0 ;
11674 char *kwnames[] = {
11675 (char *) "self",(char *) "name",(char *) "type", NULL
11676 };
11677
11678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11680 if (SWIG_arg_fail(1)) SWIG_fail;
11681 {
11682 arg2 = wxString_in_helper(obj1);
11683 if (arg2 == NULL) SWIG_fail;
11684 temp2 = true;
11685 }
11686 {
11687 arg3 = (int)(SWIG_As_int(obj2));
11688 if (SWIG_arg_fail(3)) SWIG_fail;
11689 }
11690 {
11691 PyThreadState* __tstate = wxPyBeginAllowThreads();
11692 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11693
11694 wxPyEndAllowThreads(__tstate);
11695 if (PyErr_Occurred()) SWIG_fail;
11696 }
11697 {
11698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11699 }
11700 {
11701 if (temp2)
11702 delete arg2;
11703 }
11704 return resultobj;
11705 fail:
11706 {
11707 if (temp2)
11708 delete arg2;
11709 }
11710 return NULL;
11711 }
11712
11713
11714 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11715 PyObject *resultobj;
11716 wxImage *arg1 = (wxImage *) 0 ;
11717 wxString *arg2 = 0 ;
11718 wxString *arg3 = 0 ;
11719 bool result;
11720 bool temp2 = false ;
11721 bool temp3 = false ;
11722 PyObject * obj0 = 0 ;
11723 PyObject * obj1 = 0 ;
11724 PyObject * obj2 = 0 ;
11725 char *kwnames[] = {
11726 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11727 };
11728
11729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11731 if (SWIG_arg_fail(1)) SWIG_fail;
11732 {
11733 arg2 = wxString_in_helper(obj1);
11734 if (arg2 == NULL) SWIG_fail;
11735 temp2 = true;
11736 }
11737 {
11738 arg3 = wxString_in_helper(obj2);
11739 if (arg3 == NULL) SWIG_fail;
11740 temp3 = true;
11741 }
11742 {
11743 PyThreadState* __tstate = wxPyBeginAllowThreads();
11744 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11745
11746 wxPyEndAllowThreads(__tstate);
11747 if (PyErr_Occurred()) SWIG_fail;
11748 }
11749 {
11750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11751 }
11752 {
11753 if (temp2)
11754 delete arg2;
11755 }
11756 {
11757 if (temp3)
11758 delete arg3;
11759 }
11760 return resultobj;
11761 fail:
11762 {
11763 if (temp2)
11764 delete arg2;
11765 }
11766 {
11767 if (temp3)
11768 delete arg3;
11769 }
11770 return NULL;
11771 }
11772
11773
11774 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11775 PyObject *resultobj;
11776 wxInputStream *arg1 = 0 ;
11777 bool result;
11778 wxPyInputStream *temp1 ;
11779 bool created1 ;
11780 PyObject * obj0 = 0 ;
11781 char *kwnames[] = {
11782 (char *) "stream", NULL
11783 };
11784
11785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11786 {
11787 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11788 arg1 = temp1->m_wxis;
11789 created1 = false;
11790 } else {
11791 PyErr_Clear(); // clear the failure of the wxPyConvert above
11792 arg1 = wxPyCBInputStream_create(obj0, false);
11793 if (arg1 == NULL) {
11794 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11795 SWIG_fail;
11796 }
11797 created1 = true;
11798 }
11799 }
11800 {
11801 PyThreadState* __tstate = wxPyBeginAllowThreads();
11802 result = (bool)wxImage::CanRead(*arg1);
11803
11804 wxPyEndAllowThreads(__tstate);
11805 if (PyErr_Occurred()) SWIG_fail;
11806 }
11807 {
11808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11809 }
11810 {
11811 if (created1)
11812 delete arg1;
11813 }
11814 return resultobj;
11815 fail:
11816 {
11817 if (created1)
11818 delete arg1;
11819 }
11820 return NULL;
11821 }
11822
11823
11824 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11825 PyObject *resultobj;
11826 wxImage *arg1 = (wxImage *) 0 ;
11827 wxInputStream *arg2 = 0 ;
11828 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11829 int arg4 = (int) -1 ;
11830 bool result;
11831 wxPyInputStream *temp2 ;
11832 bool created2 ;
11833 PyObject * obj0 = 0 ;
11834 PyObject * obj1 = 0 ;
11835 PyObject * obj2 = 0 ;
11836 PyObject * obj3 = 0 ;
11837 char *kwnames[] = {
11838 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11839 };
11840
11841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11843 if (SWIG_arg_fail(1)) SWIG_fail;
11844 {
11845 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11846 arg2 = temp2->m_wxis;
11847 created2 = false;
11848 } else {
11849 PyErr_Clear(); // clear the failure of the wxPyConvert above
11850 arg2 = wxPyCBInputStream_create(obj1, false);
11851 if (arg2 == NULL) {
11852 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11853 SWIG_fail;
11854 }
11855 created2 = true;
11856 }
11857 }
11858 if (obj2) {
11859 {
11860 arg3 = (long)(SWIG_As_long(obj2));
11861 if (SWIG_arg_fail(3)) SWIG_fail;
11862 }
11863 }
11864 if (obj3) {
11865 {
11866 arg4 = (int)(SWIG_As_int(obj3));
11867 if (SWIG_arg_fail(4)) SWIG_fail;
11868 }
11869 }
11870 {
11871 PyThreadState* __tstate = wxPyBeginAllowThreads();
11872 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
11873
11874 wxPyEndAllowThreads(__tstate);
11875 if (PyErr_Occurred()) SWIG_fail;
11876 }
11877 {
11878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11879 }
11880 {
11881 if (created2)
11882 delete arg2;
11883 }
11884 return resultobj;
11885 fail:
11886 {
11887 if (created2)
11888 delete arg2;
11889 }
11890 return NULL;
11891 }
11892
11893
11894 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
11895 PyObject *resultobj;
11896 wxImage *arg1 = (wxImage *) 0 ;
11897 wxInputStream *arg2 = 0 ;
11898 wxString *arg3 = 0 ;
11899 int arg4 = (int) -1 ;
11900 bool result;
11901 wxPyInputStream *temp2 ;
11902 bool created2 ;
11903 bool temp3 = false ;
11904 PyObject * obj0 = 0 ;
11905 PyObject * obj1 = 0 ;
11906 PyObject * obj2 = 0 ;
11907 PyObject * obj3 = 0 ;
11908 char *kwnames[] = {
11909 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
11910 };
11911
11912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11914 if (SWIG_arg_fail(1)) SWIG_fail;
11915 {
11916 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11917 arg2 = temp2->m_wxis;
11918 created2 = false;
11919 } else {
11920 PyErr_Clear(); // clear the failure of the wxPyConvert above
11921 arg2 = wxPyCBInputStream_create(obj1, false);
11922 if (arg2 == NULL) {
11923 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11924 SWIG_fail;
11925 }
11926 created2 = true;
11927 }
11928 }
11929 {
11930 arg3 = wxString_in_helper(obj2);
11931 if (arg3 == NULL) SWIG_fail;
11932 temp3 = true;
11933 }
11934 if (obj3) {
11935 {
11936 arg4 = (int)(SWIG_As_int(obj3));
11937 if (SWIG_arg_fail(4)) SWIG_fail;
11938 }
11939 }
11940 {
11941 PyThreadState* __tstate = wxPyBeginAllowThreads();
11942 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
11943
11944 wxPyEndAllowThreads(__tstate);
11945 if (PyErr_Occurred()) SWIG_fail;
11946 }
11947 {
11948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11949 }
11950 {
11951 if (created2)
11952 delete arg2;
11953 }
11954 {
11955 if (temp3)
11956 delete arg3;
11957 }
11958 return resultobj;
11959 fail:
11960 {
11961 if (created2)
11962 delete arg2;
11963 }
11964 {
11965 if (temp3)
11966 delete arg3;
11967 }
11968 return NULL;
11969 }
11970
11971
11972 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
11973 PyObject *resultobj;
11974 wxImage *arg1 = (wxImage *) 0 ;
11975 bool result;
11976 PyObject * obj0 = 0 ;
11977 char *kwnames[] = {
11978 (char *) "self", NULL
11979 };
11980
11981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
11982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11983 if (SWIG_arg_fail(1)) SWIG_fail;
11984 {
11985 PyThreadState* __tstate = wxPyBeginAllowThreads();
11986 result = (bool)(arg1)->Ok();
11987
11988 wxPyEndAllowThreads(__tstate);
11989 if (PyErr_Occurred()) SWIG_fail;
11990 }
11991 {
11992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11993 }
11994 return resultobj;
11995 fail:
11996 return NULL;
11997 }
11998
11999
12000 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12001 PyObject *resultobj;
12002 wxImage *arg1 = (wxImage *) 0 ;
12003 int result;
12004 PyObject * obj0 = 0 ;
12005 char *kwnames[] = {
12006 (char *) "self", NULL
12007 };
12008
12009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12011 if (SWIG_arg_fail(1)) SWIG_fail;
12012 {
12013 PyThreadState* __tstate = wxPyBeginAllowThreads();
12014 result = (int)(arg1)->GetWidth();
12015
12016 wxPyEndAllowThreads(__tstate);
12017 if (PyErr_Occurred()) SWIG_fail;
12018 }
12019 {
12020 resultobj = SWIG_From_int((int)(result));
12021 }
12022 return resultobj;
12023 fail:
12024 return NULL;
12025 }
12026
12027
12028 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12029 PyObject *resultobj;
12030 wxImage *arg1 = (wxImage *) 0 ;
12031 int result;
12032 PyObject * obj0 = 0 ;
12033 char *kwnames[] = {
12034 (char *) "self", NULL
12035 };
12036
12037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12039 if (SWIG_arg_fail(1)) SWIG_fail;
12040 {
12041 PyThreadState* __tstate = wxPyBeginAllowThreads();
12042 result = (int)(arg1)->GetHeight();
12043
12044 wxPyEndAllowThreads(__tstate);
12045 if (PyErr_Occurred()) SWIG_fail;
12046 }
12047 {
12048 resultobj = SWIG_From_int((int)(result));
12049 }
12050 return resultobj;
12051 fail:
12052 return NULL;
12053 }
12054
12055
12056 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12057 PyObject *resultobj;
12058 wxImage *arg1 = (wxImage *) 0 ;
12059 wxSize result;
12060 PyObject * obj0 = 0 ;
12061 char *kwnames[] = {
12062 (char *) "self", NULL
12063 };
12064
12065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12067 if (SWIG_arg_fail(1)) SWIG_fail;
12068 {
12069 PyThreadState* __tstate = wxPyBeginAllowThreads();
12070 result = wxImage_GetSize(arg1);
12071
12072 wxPyEndAllowThreads(__tstate);
12073 if (PyErr_Occurred()) SWIG_fail;
12074 }
12075 {
12076 wxSize * resultptr;
12077 resultptr = new wxSize((wxSize &)(result));
12078 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12079 }
12080 return resultobj;
12081 fail:
12082 return NULL;
12083 }
12084
12085
12086 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12087 PyObject *resultobj;
12088 wxImage *arg1 = (wxImage *) 0 ;
12089 wxRect *arg2 = 0 ;
12090 SwigValueWrapper<wxImage > result;
12091 wxRect temp2 ;
12092 PyObject * obj0 = 0 ;
12093 PyObject * obj1 = 0 ;
12094 char *kwnames[] = {
12095 (char *) "self",(char *) "rect", NULL
12096 };
12097
12098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12100 if (SWIG_arg_fail(1)) SWIG_fail;
12101 {
12102 arg2 = &temp2;
12103 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12104 }
12105 {
12106 PyThreadState* __tstate = wxPyBeginAllowThreads();
12107 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12108
12109 wxPyEndAllowThreads(__tstate);
12110 if (PyErr_Occurred()) SWIG_fail;
12111 }
12112 {
12113 wxImage * resultptr;
12114 resultptr = new wxImage((wxImage &)(result));
12115 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12116 }
12117 return resultobj;
12118 fail:
12119 return NULL;
12120 }
12121
12122
12123 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12124 PyObject *resultobj;
12125 wxImage *arg1 = (wxImage *) 0 ;
12126 SwigValueWrapper<wxImage > result;
12127 PyObject * obj0 = 0 ;
12128 char *kwnames[] = {
12129 (char *) "self", NULL
12130 };
12131
12132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12134 if (SWIG_arg_fail(1)) SWIG_fail;
12135 {
12136 PyThreadState* __tstate = wxPyBeginAllowThreads();
12137 result = (arg1)->Copy();
12138
12139 wxPyEndAllowThreads(__tstate);
12140 if (PyErr_Occurred()) SWIG_fail;
12141 }
12142 {
12143 wxImage * resultptr;
12144 resultptr = new wxImage((wxImage &)(result));
12145 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12146 }
12147 return resultobj;
12148 fail:
12149 return NULL;
12150 }
12151
12152
12153 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12154 PyObject *resultobj;
12155 wxImage *arg1 = (wxImage *) 0 ;
12156 wxImage *arg2 = 0 ;
12157 int arg3 ;
12158 int arg4 ;
12159 PyObject * obj0 = 0 ;
12160 PyObject * obj1 = 0 ;
12161 PyObject * obj2 = 0 ;
12162 PyObject * obj3 = 0 ;
12163 char *kwnames[] = {
12164 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12165 };
12166
12167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12169 if (SWIG_arg_fail(1)) SWIG_fail;
12170 {
12171 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12172 if (SWIG_arg_fail(2)) SWIG_fail;
12173 if (arg2 == NULL) {
12174 SWIG_null_ref("wxImage");
12175 }
12176 if (SWIG_arg_fail(2)) SWIG_fail;
12177 }
12178 {
12179 arg3 = (int)(SWIG_As_int(obj2));
12180 if (SWIG_arg_fail(3)) SWIG_fail;
12181 }
12182 {
12183 arg4 = (int)(SWIG_As_int(obj3));
12184 if (SWIG_arg_fail(4)) SWIG_fail;
12185 }
12186 {
12187 PyThreadState* __tstate = wxPyBeginAllowThreads();
12188 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12189
12190 wxPyEndAllowThreads(__tstate);
12191 if (PyErr_Occurred()) SWIG_fail;
12192 }
12193 Py_INCREF(Py_None); resultobj = Py_None;
12194 return resultobj;
12195 fail:
12196 return NULL;
12197 }
12198
12199
12200 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12201 PyObject *resultobj;
12202 wxImage *arg1 = (wxImage *) 0 ;
12203 PyObject *result;
12204 PyObject * obj0 = 0 ;
12205 char *kwnames[] = {
12206 (char *) "self", NULL
12207 };
12208
12209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12211 if (SWIG_arg_fail(1)) SWIG_fail;
12212 {
12213 PyThreadState* __tstate = wxPyBeginAllowThreads();
12214 result = (PyObject *)wxImage_GetData(arg1);
12215
12216 wxPyEndAllowThreads(__tstate);
12217 if (PyErr_Occurred()) SWIG_fail;
12218 }
12219 resultobj = result;
12220 return resultobj;
12221 fail:
12222 return NULL;
12223 }
12224
12225
12226 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12227 PyObject *resultobj;
12228 wxImage *arg1 = (wxImage *) 0 ;
12229 PyObject *arg2 = (PyObject *) 0 ;
12230 PyObject * obj0 = 0 ;
12231 PyObject * obj1 = 0 ;
12232 char *kwnames[] = {
12233 (char *) "self",(char *) "data", NULL
12234 };
12235
12236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12238 if (SWIG_arg_fail(1)) SWIG_fail;
12239 arg2 = obj1;
12240 {
12241 PyThreadState* __tstate = wxPyBeginAllowThreads();
12242 wxImage_SetData(arg1,arg2);
12243
12244 wxPyEndAllowThreads(__tstate);
12245 if (PyErr_Occurred()) SWIG_fail;
12246 }
12247 Py_INCREF(Py_None); resultobj = Py_None;
12248 return resultobj;
12249 fail:
12250 return NULL;
12251 }
12252
12253
12254 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12255 PyObject *resultobj;
12256 wxImage *arg1 = (wxImage *) 0 ;
12257 PyObject *result;
12258 PyObject * obj0 = 0 ;
12259 char *kwnames[] = {
12260 (char *) "self", NULL
12261 };
12262
12263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12265 if (SWIG_arg_fail(1)) SWIG_fail;
12266 {
12267 PyThreadState* __tstate = wxPyBeginAllowThreads();
12268 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12269
12270 wxPyEndAllowThreads(__tstate);
12271 if (PyErr_Occurred()) SWIG_fail;
12272 }
12273 resultobj = result;
12274 return resultobj;
12275 fail:
12276 return NULL;
12277 }
12278
12279
12280 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12281 PyObject *resultobj;
12282 wxImage *arg1 = (wxImage *) 0 ;
12283 PyObject *arg2 = (PyObject *) 0 ;
12284 PyObject * obj0 = 0 ;
12285 PyObject * obj1 = 0 ;
12286 char *kwnames[] = {
12287 (char *) "self",(char *) "data", NULL
12288 };
12289
12290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12292 if (SWIG_arg_fail(1)) SWIG_fail;
12293 arg2 = obj1;
12294 {
12295 PyThreadState* __tstate = wxPyBeginAllowThreads();
12296 wxImage_SetDataBuffer(arg1,arg2);
12297
12298 wxPyEndAllowThreads(__tstate);
12299 if (PyErr_Occurred()) SWIG_fail;
12300 }
12301 Py_INCREF(Py_None); resultobj = Py_None;
12302 return resultobj;
12303 fail:
12304 return NULL;
12305 }
12306
12307
12308 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12309 PyObject *resultobj;
12310 wxImage *arg1 = (wxImage *) 0 ;
12311 PyObject *result;
12312 PyObject * obj0 = 0 ;
12313 char *kwnames[] = {
12314 (char *) "self", NULL
12315 };
12316
12317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12319 if (SWIG_arg_fail(1)) SWIG_fail;
12320 {
12321 PyThreadState* __tstate = wxPyBeginAllowThreads();
12322 result = (PyObject *)wxImage_GetAlphaData(arg1);
12323
12324 wxPyEndAllowThreads(__tstate);
12325 if (PyErr_Occurred()) SWIG_fail;
12326 }
12327 resultobj = result;
12328 return resultobj;
12329 fail:
12330 return NULL;
12331 }
12332
12333
12334 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12335 PyObject *resultobj;
12336 wxImage *arg1 = (wxImage *) 0 ;
12337 PyObject *arg2 = (PyObject *) 0 ;
12338 PyObject * obj0 = 0 ;
12339 PyObject * obj1 = 0 ;
12340 char *kwnames[] = {
12341 (char *) "self",(char *) "data", NULL
12342 };
12343
12344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12346 if (SWIG_arg_fail(1)) SWIG_fail;
12347 arg2 = obj1;
12348 {
12349 PyThreadState* __tstate = wxPyBeginAllowThreads();
12350 wxImage_SetAlphaData(arg1,arg2);
12351
12352 wxPyEndAllowThreads(__tstate);
12353 if (PyErr_Occurred()) SWIG_fail;
12354 }
12355 Py_INCREF(Py_None); resultobj = Py_None;
12356 return resultobj;
12357 fail:
12358 return NULL;
12359 }
12360
12361
12362 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12363 PyObject *resultobj;
12364 wxImage *arg1 = (wxImage *) 0 ;
12365 PyObject *result;
12366 PyObject * obj0 = 0 ;
12367 char *kwnames[] = {
12368 (char *) "self", NULL
12369 };
12370
12371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12373 if (SWIG_arg_fail(1)) SWIG_fail;
12374 {
12375 PyThreadState* __tstate = wxPyBeginAllowThreads();
12376 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12377
12378 wxPyEndAllowThreads(__tstate);
12379 if (PyErr_Occurred()) SWIG_fail;
12380 }
12381 resultobj = result;
12382 return resultobj;
12383 fail:
12384 return NULL;
12385 }
12386
12387
12388 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12389 PyObject *resultobj;
12390 wxImage *arg1 = (wxImage *) 0 ;
12391 PyObject *arg2 = (PyObject *) 0 ;
12392 PyObject * obj0 = 0 ;
12393 PyObject * obj1 = 0 ;
12394 char *kwnames[] = {
12395 (char *) "self",(char *) "data", NULL
12396 };
12397
12398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) 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 arg2 = obj1;
12402 {
12403 PyThreadState* __tstate = wxPyBeginAllowThreads();
12404 wxImage_SetAlphaBuffer(arg1,arg2);
12405
12406 wxPyEndAllowThreads(__tstate);
12407 if (PyErr_Occurred()) SWIG_fail;
12408 }
12409 Py_INCREF(Py_None); resultobj = Py_None;
12410 return resultobj;
12411 fail:
12412 return NULL;
12413 }
12414
12415
12416 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12417 PyObject *resultobj;
12418 wxImage *arg1 = (wxImage *) 0 ;
12419 unsigned char arg2 ;
12420 unsigned char arg3 ;
12421 unsigned char arg4 ;
12422 PyObject * obj0 = 0 ;
12423 PyObject * obj1 = 0 ;
12424 PyObject * obj2 = 0 ;
12425 PyObject * obj3 = 0 ;
12426 char *kwnames[] = {
12427 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12428 };
12429
12430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12432 if (SWIG_arg_fail(1)) SWIG_fail;
12433 {
12434 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12435 if (SWIG_arg_fail(2)) SWIG_fail;
12436 }
12437 {
12438 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12439 if (SWIG_arg_fail(3)) SWIG_fail;
12440 }
12441 {
12442 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12443 if (SWIG_arg_fail(4)) SWIG_fail;
12444 }
12445 {
12446 PyThreadState* __tstate = wxPyBeginAllowThreads();
12447 (arg1)->SetMaskColour(arg2,arg3,arg4);
12448
12449 wxPyEndAllowThreads(__tstate);
12450 if (PyErr_Occurred()) SWIG_fail;
12451 }
12452 Py_INCREF(Py_None); resultobj = Py_None;
12453 return resultobj;
12454 fail:
12455 return NULL;
12456 }
12457
12458
12459 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12460 PyObject *resultobj;
12461 wxImage *arg1 = (wxImage *) 0 ;
12462 unsigned char result;
12463 PyObject * obj0 = 0 ;
12464 char *kwnames[] = {
12465 (char *) "self", NULL
12466 };
12467
12468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12470 if (SWIG_arg_fail(1)) SWIG_fail;
12471 {
12472 PyThreadState* __tstate = wxPyBeginAllowThreads();
12473 result = (unsigned char)(arg1)->GetMaskRed();
12474
12475 wxPyEndAllowThreads(__tstate);
12476 if (PyErr_Occurred()) SWIG_fail;
12477 }
12478 {
12479 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12480 }
12481 return resultobj;
12482 fail:
12483 return NULL;
12484 }
12485
12486
12487 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12488 PyObject *resultobj;
12489 wxImage *arg1 = (wxImage *) 0 ;
12490 unsigned char result;
12491 PyObject * obj0 = 0 ;
12492 char *kwnames[] = {
12493 (char *) "self", NULL
12494 };
12495
12496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12498 if (SWIG_arg_fail(1)) SWIG_fail;
12499 {
12500 PyThreadState* __tstate = wxPyBeginAllowThreads();
12501 result = (unsigned char)(arg1)->GetMaskGreen();
12502
12503 wxPyEndAllowThreads(__tstate);
12504 if (PyErr_Occurred()) SWIG_fail;
12505 }
12506 {
12507 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12508 }
12509 return resultobj;
12510 fail:
12511 return NULL;
12512 }
12513
12514
12515 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12516 PyObject *resultobj;
12517 wxImage *arg1 = (wxImage *) 0 ;
12518 unsigned char result;
12519 PyObject * obj0 = 0 ;
12520 char *kwnames[] = {
12521 (char *) "self", NULL
12522 };
12523
12524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12526 if (SWIG_arg_fail(1)) SWIG_fail;
12527 {
12528 PyThreadState* __tstate = wxPyBeginAllowThreads();
12529 result = (unsigned char)(arg1)->GetMaskBlue();
12530
12531 wxPyEndAllowThreads(__tstate);
12532 if (PyErr_Occurred()) SWIG_fail;
12533 }
12534 {
12535 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12536 }
12537 return resultobj;
12538 fail:
12539 return NULL;
12540 }
12541
12542
12543 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12544 PyObject *resultobj;
12545 wxImage *arg1 = (wxImage *) 0 ;
12546 bool arg2 = (bool) true ;
12547 PyObject * obj0 = 0 ;
12548 PyObject * obj1 = 0 ;
12549 char *kwnames[] = {
12550 (char *) "self",(char *) "mask", NULL
12551 };
12552
12553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) 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 if (obj1) {
12557 {
12558 arg2 = (bool)(SWIG_As_bool(obj1));
12559 if (SWIG_arg_fail(2)) SWIG_fail;
12560 }
12561 }
12562 {
12563 PyThreadState* __tstate = wxPyBeginAllowThreads();
12564 (arg1)->SetMask(arg2);
12565
12566 wxPyEndAllowThreads(__tstate);
12567 if (PyErr_Occurred()) SWIG_fail;
12568 }
12569 Py_INCREF(Py_None); resultobj = Py_None;
12570 return resultobj;
12571 fail:
12572 return NULL;
12573 }
12574
12575
12576 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12577 PyObject *resultobj;
12578 wxImage *arg1 = (wxImage *) 0 ;
12579 bool result;
12580 PyObject * obj0 = 0 ;
12581 char *kwnames[] = {
12582 (char *) "self", NULL
12583 };
12584
12585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12587 if (SWIG_arg_fail(1)) SWIG_fail;
12588 {
12589 PyThreadState* __tstate = wxPyBeginAllowThreads();
12590 result = (bool)(arg1)->HasMask();
12591
12592 wxPyEndAllowThreads(__tstate);
12593 if (PyErr_Occurred()) SWIG_fail;
12594 }
12595 {
12596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12597 }
12598 return resultobj;
12599 fail:
12600 return NULL;
12601 }
12602
12603
12604 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12605 PyObject *resultobj;
12606 wxImage *arg1 = (wxImage *) 0 ;
12607 double arg2 ;
12608 wxPoint *arg3 = 0 ;
12609 bool arg4 = (bool) true ;
12610 wxPoint *arg5 = (wxPoint *) NULL ;
12611 SwigValueWrapper<wxImage > result;
12612 wxPoint temp3 ;
12613 PyObject * obj0 = 0 ;
12614 PyObject * obj1 = 0 ;
12615 PyObject * obj2 = 0 ;
12616 PyObject * obj3 = 0 ;
12617 PyObject * obj4 = 0 ;
12618 char *kwnames[] = {
12619 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12620 };
12621
12622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12624 if (SWIG_arg_fail(1)) SWIG_fail;
12625 {
12626 arg2 = (double)(SWIG_As_double(obj1));
12627 if (SWIG_arg_fail(2)) SWIG_fail;
12628 }
12629 {
12630 arg3 = &temp3;
12631 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12632 }
12633 if (obj3) {
12634 {
12635 arg4 = (bool)(SWIG_As_bool(obj3));
12636 if (SWIG_arg_fail(4)) SWIG_fail;
12637 }
12638 }
12639 if (obj4) {
12640 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12641 if (SWIG_arg_fail(5)) SWIG_fail;
12642 }
12643 {
12644 PyThreadState* __tstate = wxPyBeginAllowThreads();
12645 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12646
12647 wxPyEndAllowThreads(__tstate);
12648 if (PyErr_Occurred()) SWIG_fail;
12649 }
12650 {
12651 wxImage * resultptr;
12652 resultptr = new wxImage((wxImage &)(result));
12653 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12654 }
12655 return resultobj;
12656 fail:
12657 return NULL;
12658 }
12659
12660
12661 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12662 PyObject *resultobj;
12663 wxImage *arg1 = (wxImage *) 0 ;
12664 bool arg2 = (bool) true ;
12665 SwigValueWrapper<wxImage > result;
12666 PyObject * obj0 = 0 ;
12667 PyObject * obj1 = 0 ;
12668 char *kwnames[] = {
12669 (char *) "self",(char *) "clockwise", NULL
12670 };
12671
12672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12674 if (SWIG_arg_fail(1)) SWIG_fail;
12675 if (obj1) {
12676 {
12677 arg2 = (bool)(SWIG_As_bool(obj1));
12678 if (SWIG_arg_fail(2)) SWIG_fail;
12679 }
12680 }
12681 {
12682 PyThreadState* __tstate = wxPyBeginAllowThreads();
12683 result = (arg1)->Rotate90(arg2);
12684
12685 wxPyEndAllowThreads(__tstate);
12686 if (PyErr_Occurred()) SWIG_fail;
12687 }
12688 {
12689 wxImage * resultptr;
12690 resultptr = new wxImage((wxImage &)(result));
12691 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12692 }
12693 return resultobj;
12694 fail:
12695 return NULL;
12696 }
12697
12698
12699 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12700 PyObject *resultobj;
12701 wxImage *arg1 = (wxImage *) 0 ;
12702 bool arg2 = (bool) true ;
12703 SwigValueWrapper<wxImage > result;
12704 PyObject * obj0 = 0 ;
12705 PyObject * obj1 = 0 ;
12706 char *kwnames[] = {
12707 (char *) "self",(char *) "horizontally", NULL
12708 };
12709
12710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12712 if (SWIG_arg_fail(1)) SWIG_fail;
12713 if (obj1) {
12714 {
12715 arg2 = (bool)(SWIG_As_bool(obj1));
12716 if (SWIG_arg_fail(2)) SWIG_fail;
12717 }
12718 }
12719 {
12720 PyThreadState* __tstate = wxPyBeginAllowThreads();
12721 result = (arg1)->Mirror(arg2);
12722
12723 wxPyEndAllowThreads(__tstate);
12724 if (PyErr_Occurred()) SWIG_fail;
12725 }
12726 {
12727 wxImage * resultptr;
12728 resultptr = new wxImage((wxImage &)(result));
12729 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12730 }
12731 return resultobj;
12732 fail:
12733 return NULL;
12734 }
12735
12736
12737 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12738 PyObject *resultobj;
12739 wxImage *arg1 = (wxImage *) 0 ;
12740 unsigned char arg2 ;
12741 unsigned char arg3 ;
12742 unsigned char arg4 ;
12743 unsigned char arg5 ;
12744 unsigned char arg6 ;
12745 unsigned char arg7 ;
12746 PyObject * obj0 = 0 ;
12747 PyObject * obj1 = 0 ;
12748 PyObject * obj2 = 0 ;
12749 PyObject * obj3 = 0 ;
12750 PyObject * obj4 = 0 ;
12751 PyObject * obj5 = 0 ;
12752 PyObject * obj6 = 0 ;
12753 char *kwnames[] = {
12754 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12755 };
12756
12757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12759 if (SWIG_arg_fail(1)) SWIG_fail;
12760 {
12761 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12762 if (SWIG_arg_fail(2)) SWIG_fail;
12763 }
12764 {
12765 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12766 if (SWIG_arg_fail(3)) SWIG_fail;
12767 }
12768 {
12769 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12770 if (SWIG_arg_fail(4)) SWIG_fail;
12771 }
12772 {
12773 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
12774 if (SWIG_arg_fail(5)) SWIG_fail;
12775 }
12776 {
12777 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
12778 if (SWIG_arg_fail(6)) SWIG_fail;
12779 }
12780 {
12781 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
12782 if (SWIG_arg_fail(7)) SWIG_fail;
12783 }
12784 {
12785 PyThreadState* __tstate = wxPyBeginAllowThreads();
12786 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
12787
12788 wxPyEndAllowThreads(__tstate);
12789 if (PyErr_Occurred()) SWIG_fail;
12790 }
12791 Py_INCREF(Py_None); resultobj = Py_None;
12792 return resultobj;
12793 fail:
12794 return NULL;
12795 }
12796
12797
12798 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
12799 PyObject *resultobj;
12800 wxImage *arg1 = (wxImage *) 0 ;
12801 unsigned char arg2 ;
12802 unsigned char arg3 ;
12803 unsigned char arg4 ;
12804 SwigValueWrapper<wxImage > result;
12805 PyObject * obj0 = 0 ;
12806 PyObject * obj1 = 0 ;
12807 PyObject * obj2 = 0 ;
12808 PyObject * obj3 = 0 ;
12809 char *kwnames[] = {
12810 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12811 };
12812
12813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12815 if (SWIG_arg_fail(1)) SWIG_fail;
12816 {
12817 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12818 if (SWIG_arg_fail(2)) SWIG_fail;
12819 }
12820 {
12821 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12822 if (SWIG_arg_fail(3)) SWIG_fail;
12823 }
12824 {
12825 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12826 if (SWIG_arg_fail(4)) SWIG_fail;
12827 }
12828 {
12829 PyThreadState* __tstate = wxPyBeginAllowThreads();
12830 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
12831
12832 wxPyEndAllowThreads(__tstate);
12833 if (PyErr_Occurred()) SWIG_fail;
12834 }
12835 {
12836 wxImage * resultptr;
12837 resultptr = new wxImage((wxImage &)(result));
12838 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12839 }
12840 return resultobj;
12841 fail:
12842 return NULL;
12843 }
12844
12845
12846 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12847 PyObject *resultobj;
12848 wxImage *arg1 = (wxImage *) 0 ;
12849 wxString *arg2 = 0 ;
12850 wxString *arg3 = 0 ;
12851 bool temp2 = false ;
12852 bool temp3 = false ;
12853 PyObject * obj0 = 0 ;
12854 PyObject * obj1 = 0 ;
12855 PyObject * obj2 = 0 ;
12856 char *kwnames[] = {
12857 (char *) "self",(char *) "name",(char *) "value", NULL
12858 };
12859
12860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
12861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12862 if (SWIG_arg_fail(1)) SWIG_fail;
12863 {
12864 arg2 = wxString_in_helper(obj1);
12865 if (arg2 == NULL) SWIG_fail;
12866 temp2 = true;
12867 }
12868 {
12869 arg3 = wxString_in_helper(obj2);
12870 if (arg3 == NULL) SWIG_fail;
12871 temp3 = true;
12872 }
12873 {
12874 PyThreadState* __tstate = wxPyBeginAllowThreads();
12875 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
12876
12877 wxPyEndAllowThreads(__tstate);
12878 if (PyErr_Occurred()) SWIG_fail;
12879 }
12880 Py_INCREF(Py_None); resultobj = Py_None;
12881 {
12882 if (temp2)
12883 delete arg2;
12884 }
12885 {
12886 if (temp3)
12887 delete arg3;
12888 }
12889 return resultobj;
12890 fail:
12891 {
12892 if (temp2)
12893 delete arg2;
12894 }
12895 {
12896 if (temp3)
12897 delete arg3;
12898 }
12899 return NULL;
12900 }
12901
12902
12903 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12904 PyObject *resultobj;
12905 wxImage *arg1 = (wxImage *) 0 ;
12906 wxString *arg2 = 0 ;
12907 int arg3 ;
12908 bool temp2 = false ;
12909 PyObject * obj0 = 0 ;
12910 PyObject * obj1 = 0 ;
12911 PyObject * obj2 = 0 ;
12912 char *kwnames[] = {
12913 (char *) "self",(char *) "name",(char *) "value", NULL
12914 };
12915
12916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
12917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12918 if (SWIG_arg_fail(1)) SWIG_fail;
12919 {
12920 arg2 = wxString_in_helper(obj1);
12921 if (arg2 == NULL) SWIG_fail;
12922 temp2 = true;
12923 }
12924 {
12925 arg3 = (int)(SWIG_As_int(obj2));
12926 if (SWIG_arg_fail(3)) SWIG_fail;
12927 }
12928 {
12929 PyThreadState* __tstate = wxPyBeginAllowThreads();
12930 (arg1)->SetOption((wxString const &)*arg2,arg3);
12931
12932 wxPyEndAllowThreads(__tstate);
12933 if (PyErr_Occurred()) SWIG_fail;
12934 }
12935 Py_INCREF(Py_None); resultobj = Py_None;
12936 {
12937 if (temp2)
12938 delete arg2;
12939 }
12940 return resultobj;
12941 fail:
12942 {
12943 if (temp2)
12944 delete arg2;
12945 }
12946 return NULL;
12947 }
12948
12949
12950 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12951 PyObject *resultobj;
12952 wxImage *arg1 = (wxImage *) 0 ;
12953 wxString *arg2 = 0 ;
12954 wxString result;
12955 bool temp2 = false ;
12956 PyObject * obj0 = 0 ;
12957 PyObject * obj1 = 0 ;
12958 char *kwnames[] = {
12959 (char *) "self",(char *) "name", NULL
12960 };
12961
12962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
12963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12964 if (SWIG_arg_fail(1)) SWIG_fail;
12965 {
12966 arg2 = wxString_in_helper(obj1);
12967 if (arg2 == NULL) SWIG_fail;
12968 temp2 = true;
12969 }
12970 {
12971 PyThreadState* __tstate = wxPyBeginAllowThreads();
12972 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
12973
12974 wxPyEndAllowThreads(__tstate);
12975 if (PyErr_Occurred()) SWIG_fail;
12976 }
12977 {
12978 #if wxUSE_UNICODE
12979 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12980 #else
12981 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12982 #endif
12983 }
12984 {
12985 if (temp2)
12986 delete arg2;
12987 }
12988 return resultobj;
12989 fail:
12990 {
12991 if (temp2)
12992 delete arg2;
12993 }
12994 return NULL;
12995 }
12996
12997
12998 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12999 PyObject *resultobj;
13000 wxImage *arg1 = (wxImage *) 0 ;
13001 wxString *arg2 = 0 ;
13002 int result;
13003 bool temp2 = false ;
13004 PyObject * obj0 = 0 ;
13005 PyObject * obj1 = 0 ;
13006 char *kwnames[] = {
13007 (char *) "self",(char *) "name", NULL
13008 };
13009
13010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13012 if (SWIG_arg_fail(1)) SWIG_fail;
13013 {
13014 arg2 = wxString_in_helper(obj1);
13015 if (arg2 == NULL) SWIG_fail;
13016 temp2 = true;
13017 }
13018 {
13019 PyThreadState* __tstate = wxPyBeginAllowThreads();
13020 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13021
13022 wxPyEndAllowThreads(__tstate);
13023 if (PyErr_Occurred()) SWIG_fail;
13024 }
13025 {
13026 resultobj = SWIG_From_int((int)(result));
13027 }
13028 {
13029 if (temp2)
13030 delete arg2;
13031 }
13032 return resultobj;
13033 fail:
13034 {
13035 if (temp2)
13036 delete arg2;
13037 }
13038 return NULL;
13039 }
13040
13041
13042 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13043 PyObject *resultobj;
13044 wxImage *arg1 = (wxImage *) 0 ;
13045 wxString *arg2 = 0 ;
13046 bool result;
13047 bool temp2 = false ;
13048 PyObject * obj0 = 0 ;
13049 PyObject * obj1 = 0 ;
13050 char *kwnames[] = {
13051 (char *) "self",(char *) "name", NULL
13052 };
13053
13054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13056 if (SWIG_arg_fail(1)) SWIG_fail;
13057 {
13058 arg2 = wxString_in_helper(obj1);
13059 if (arg2 == NULL) SWIG_fail;
13060 temp2 = true;
13061 }
13062 {
13063 PyThreadState* __tstate = wxPyBeginAllowThreads();
13064 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13065
13066 wxPyEndAllowThreads(__tstate);
13067 if (PyErr_Occurred()) SWIG_fail;
13068 }
13069 {
13070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13071 }
13072 {
13073 if (temp2)
13074 delete arg2;
13075 }
13076 return resultobj;
13077 fail:
13078 {
13079 if (temp2)
13080 delete arg2;
13081 }
13082 return NULL;
13083 }
13084
13085
13086 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13087 PyObject *resultobj;
13088 wxImage *arg1 = (wxImage *) 0 ;
13089 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13090 unsigned long result;
13091 PyObject * obj0 = 0 ;
13092 PyObject * obj1 = 0 ;
13093 char *kwnames[] = {
13094 (char *) "self",(char *) "stopafter", NULL
13095 };
13096
13097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13099 if (SWIG_arg_fail(1)) SWIG_fail;
13100 if (obj1) {
13101 {
13102 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13103 if (SWIG_arg_fail(2)) SWIG_fail;
13104 }
13105 }
13106 {
13107 PyThreadState* __tstate = wxPyBeginAllowThreads();
13108 result = (unsigned long)(arg1)->CountColours(arg2);
13109
13110 wxPyEndAllowThreads(__tstate);
13111 if (PyErr_Occurred()) SWIG_fail;
13112 }
13113 {
13114 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13115 }
13116 return resultobj;
13117 fail:
13118 return NULL;
13119 }
13120
13121
13122 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13123 PyObject *resultobj;
13124 wxImage *arg1 = (wxImage *) 0 ;
13125 wxImageHistogram *arg2 = 0 ;
13126 unsigned long result;
13127 PyObject * obj0 = 0 ;
13128 PyObject * obj1 = 0 ;
13129 char *kwnames[] = {
13130 (char *) "self",(char *) "h", NULL
13131 };
13132
13133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13135 if (SWIG_arg_fail(1)) SWIG_fail;
13136 {
13137 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13138 if (SWIG_arg_fail(2)) SWIG_fail;
13139 if (arg2 == NULL) {
13140 SWIG_null_ref("wxImageHistogram");
13141 }
13142 if (SWIG_arg_fail(2)) SWIG_fail;
13143 }
13144 {
13145 PyThreadState* __tstate = wxPyBeginAllowThreads();
13146 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13147
13148 wxPyEndAllowThreads(__tstate);
13149 if (PyErr_Occurred()) SWIG_fail;
13150 }
13151 {
13152 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13153 }
13154 return resultobj;
13155 fail:
13156 return NULL;
13157 }
13158
13159
13160 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13161 PyObject *resultobj;
13162 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13163 PyObject * obj0 = 0 ;
13164 char *kwnames[] = {
13165 (char *) "handler", NULL
13166 };
13167
13168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13170 if (SWIG_arg_fail(1)) SWIG_fail;
13171 {
13172 PyThreadState* __tstate = wxPyBeginAllowThreads();
13173 wxImage::AddHandler(arg1);
13174
13175 wxPyEndAllowThreads(__tstate);
13176 if (PyErr_Occurred()) SWIG_fail;
13177 }
13178 Py_INCREF(Py_None); resultobj = Py_None;
13179 return resultobj;
13180 fail:
13181 return NULL;
13182 }
13183
13184
13185 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13186 PyObject *resultobj;
13187 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13188 PyObject * obj0 = 0 ;
13189 char *kwnames[] = {
13190 (char *) "handler", NULL
13191 };
13192
13193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13195 if (SWIG_arg_fail(1)) SWIG_fail;
13196 {
13197 PyThreadState* __tstate = wxPyBeginAllowThreads();
13198 wxImage::InsertHandler(arg1);
13199
13200 wxPyEndAllowThreads(__tstate);
13201 if (PyErr_Occurred()) SWIG_fail;
13202 }
13203 Py_INCREF(Py_None); resultobj = Py_None;
13204 return resultobj;
13205 fail:
13206 return NULL;
13207 }
13208
13209
13210 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13211 PyObject *resultobj;
13212 wxString *arg1 = 0 ;
13213 bool result;
13214 bool temp1 = false ;
13215 PyObject * obj0 = 0 ;
13216 char *kwnames[] = {
13217 (char *) "name", NULL
13218 };
13219
13220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13221 {
13222 arg1 = wxString_in_helper(obj0);
13223 if (arg1 == NULL) SWIG_fail;
13224 temp1 = true;
13225 }
13226 {
13227 PyThreadState* __tstate = wxPyBeginAllowThreads();
13228 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13229
13230 wxPyEndAllowThreads(__tstate);
13231 if (PyErr_Occurred()) SWIG_fail;
13232 }
13233 {
13234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13235 }
13236 {
13237 if (temp1)
13238 delete arg1;
13239 }
13240 return resultobj;
13241 fail:
13242 {
13243 if (temp1)
13244 delete arg1;
13245 }
13246 return NULL;
13247 }
13248
13249
13250 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13251 PyObject *resultobj;
13252 wxString result;
13253 char *kwnames[] = {
13254 NULL
13255 };
13256
13257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13258 {
13259 PyThreadState* __tstate = wxPyBeginAllowThreads();
13260 result = wxImage::GetImageExtWildcard();
13261
13262 wxPyEndAllowThreads(__tstate);
13263 if (PyErr_Occurred()) SWIG_fail;
13264 }
13265 {
13266 #if wxUSE_UNICODE
13267 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13268 #else
13269 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13270 #endif
13271 }
13272 return resultobj;
13273 fail:
13274 return NULL;
13275 }
13276
13277
13278 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13279 PyObject *resultobj;
13280 wxImage *arg1 = (wxImage *) 0 ;
13281 int arg2 = (int) -1 ;
13282 wxBitmap result;
13283 PyObject * obj0 = 0 ;
13284 PyObject * obj1 = 0 ;
13285 char *kwnames[] = {
13286 (char *) "self",(char *) "depth", NULL
13287 };
13288
13289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13291 if (SWIG_arg_fail(1)) SWIG_fail;
13292 if (obj1) {
13293 {
13294 arg2 = (int)(SWIG_As_int(obj1));
13295 if (SWIG_arg_fail(2)) SWIG_fail;
13296 }
13297 }
13298 {
13299 if (!wxPyCheckForApp()) SWIG_fail;
13300 PyThreadState* __tstate = wxPyBeginAllowThreads();
13301 result = wxImage_ConvertToBitmap(arg1,arg2);
13302
13303 wxPyEndAllowThreads(__tstate);
13304 if (PyErr_Occurred()) SWIG_fail;
13305 }
13306 {
13307 wxBitmap * resultptr;
13308 resultptr = new wxBitmap((wxBitmap &)(result));
13309 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13310 }
13311 return resultobj;
13312 fail:
13313 return NULL;
13314 }
13315
13316
13317 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13318 PyObject *resultobj;
13319 wxImage *arg1 = (wxImage *) 0 ;
13320 unsigned char arg2 ;
13321 unsigned char arg3 ;
13322 unsigned char arg4 ;
13323 wxBitmap result;
13324 PyObject * obj0 = 0 ;
13325 PyObject * obj1 = 0 ;
13326 PyObject * obj2 = 0 ;
13327 PyObject * obj3 = 0 ;
13328 char *kwnames[] = {
13329 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13330 };
13331
13332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13334 if (SWIG_arg_fail(1)) SWIG_fail;
13335 {
13336 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13337 if (SWIG_arg_fail(2)) SWIG_fail;
13338 }
13339 {
13340 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13341 if (SWIG_arg_fail(3)) SWIG_fail;
13342 }
13343 {
13344 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13345 if (SWIG_arg_fail(4)) SWIG_fail;
13346 }
13347 {
13348 if (!wxPyCheckForApp()) SWIG_fail;
13349 PyThreadState* __tstate = wxPyBeginAllowThreads();
13350 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13351
13352 wxPyEndAllowThreads(__tstate);
13353 if (PyErr_Occurred()) SWIG_fail;
13354 }
13355 {
13356 wxBitmap * resultptr;
13357 resultptr = new wxBitmap((wxBitmap &)(result));
13358 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13359 }
13360 return resultobj;
13361 fail:
13362 return NULL;
13363 }
13364
13365
13366 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13367 PyObject *obj;
13368 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13369 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13370 Py_INCREF(obj);
13371 return Py_BuildValue((char *)"");
13372 }
13373 static int _wrap_NullImage_set(PyObject *) {
13374 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13375 return 1;
13376 }
13377
13378
13379 static PyObject *_wrap_NullImage_get(void) {
13380 PyObject *pyobj;
13381
13382 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13383 return pyobj;
13384 }
13385
13386
13387 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13388 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13389 return 1;
13390 }
13391
13392
13393 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13394 PyObject *pyobj;
13395
13396 {
13397 #if wxUSE_UNICODE
13398 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13399 #else
13400 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13401 #endif
13402 }
13403 return pyobj;
13404 }
13405
13406
13407 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13408 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13409 return 1;
13410 }
13411
13412
13413 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13414 PyObject *pyobj;
13415
13416 {
13417 #if wxUSE_UNICODE
13418 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13419 #else
13420 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13421 #endif
13422 }
13423 return pyobj;
13424 }
13425
13426
13427 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13428 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13429 return 1;
13430 }
13431
13432
13433 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13434 PyObject *pyobj;
13435
13436 {
13437 #if wxUSE_UNICODE
13438 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13439 #else
13440 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13441 #endif
13442 }
13443 return pyobj;
13444 }
13445
13446
13447 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13448 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13449 return 1;
13450 }
13451
13452
13453 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13454 PyObject *pyobj;
13455
13456 {
13457 #if wxUSE_UNICODE
13458 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13459 #else
13460 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13461 #endif
13462 }
13463 return pyobj;
13464 }
13465
13466
13467 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13468 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13469 return 1;
13470 }
13471
13472
13473 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13474 PyObject *pyobj;
13475
13476 {
13477 #if wxUSE_UNICODE
13478 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13479 #else
13480 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13481 #endif
13482 }
13483 return pyobj;
13484 }
13485
13486
13487 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13488 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13489 return 1;
13490 }
13491
13492
13493 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13494 PyObject *pyobj;
13495
13496 {
13497 #if wxUSE_UNICODE
13498 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13499 #else
13500 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13501 #endif
13502 }
13503 return pyobj;
13504 }
13505
13506
13507 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13508 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13509 return 1;
13510 }
13511
13512
13513 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13514 PyObject *pyobj;
13515
13516 {
13517 #if wxUSE_UNICODE
13518 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13519 #else
13520 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13521 #endif
13522 }
13523 return pyobj;
13524 }
13525
13526
13527 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13528 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13529 return 1;
13530 }
13531
13532
13533 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13534 PyObject *pyobj;
13535
13536 {
13537 #if wxUSE_UNICODE
13538 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13539 #else
13540 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13541 #endif
13542 }
13543 return pyobj;
13544 }
13545
13546
13547 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
13548 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
13549 return 1;
13550 }
13551
13552
13553 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
13554 PyObject *pyobj;
13555
13556 {
13557 #if wxUSE_UNICODE
13558 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13559 #else
13560 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13561 #endif
13562 }
13563 return pyobj;
13564 }
13565
13566
13567 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
13568 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
13569 return 1;
13570 }
13571
13572
13573 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
13574 PyObject *pyobj;
13575
13576 {
13577 #if wxUSE_UNICODE
13578 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13579 #else
13580 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13581 #endif
13582 }
13583 return pyobj;
13584 }
13585
13586
13587 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
13588 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
13589 return 1;
13590 }
13591
13592
13593 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
13594 PyObject *pyobj;
13595
13596 {
13597 #if wxUSE_UNICODE
13598 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13599 #else
13600 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13601 #endif
13602 }
13603 return pyobj;
13604 }
13605
13606
13607 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
13608 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
13609 return 1;
13610 }
13611
13612
13613 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
13614 PyObject *pyobj;
13615
13616 {
13617 #if wxUSE_UNICODE
13618 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13619 #else
13620 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13621 #endif
13622 }
13623 return pyobj;
13624 }
13625
13626
13627 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13628 PyObject *resultobj;
13629 wxBMPHandler *result;
13630 char *kwnames[] = {
13631 NULL
13632 };
13633
13634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13635 {
13636 PyThreadState* __tstate = wxPyBeginAllowThreads();
13637 result = (wxBMPHandler *)new wxBMPHandler();
13638
13639 wxPyEndAllowThreads(__tstate);
13640 if (PyErr_Occurred()) SWIG_fail;
13641 }
13642 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13643 return resultobj;
13644 fail:
13645 return NULL;
13646 }
13647
13648
13649 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13650 PyObject *obj;
13651 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13652 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13653 Py_INCREF(obj);
13654 return Py_BuildValue((char *)"");
13655 }
13656 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13657 PyObject *resultobj;
13658 wxICOHandler *result;
13659 char *kwnames[] = {
13660 NULL
13661 };
13662
13663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13664 {
13665 PyThreadState* __tstate = wxPyBeginAllowThreads();
13666 result = (wxICOHandler *)new wxICOHandler();
13667
13668 wxPyEndAllowThreads(__tstate);
13669 if (PyErr_Occurred()) SWIG_fail;
13670 }
13671 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13672 return resultobj;
13673 fail:
13674 return NULL;
13675 }
13676
13677
13678 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13679 PyObject *obj;
13680 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13681 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13682 Py_INCREF(obj);
13683 return Py_BuildValue((char *)"");
13684 }
13685 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13686 PyObject *resultobj;
13687 wxCURHandler *result;
13688 char *kwnames[] = {
13689 NULL
13690 };
13691
13692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13693 {
13694 PyThreadState* __tstate = wxPyBeginAllowThreads();
13695 result = (wxCURHandler *)new wxCURHandler();
13696
13697 wxPyEndAllowThreads(__tstate);
13698 if (PyErr_Occurred()) SWIG_fail;
13699 }
13700 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13701 return resultobj;
13702 fail:
13703 return NULL;
13704 }
13705
13706
13707 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
13708 PyObject *obj;
13709 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13710 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
13711 Py_INCREF(obj);
13712 return Py_BuildValue((char *)"");
13713 }
13714 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13715 PyObject *resultobj;
13716 wxANIHandler *result;
13717 char *kwnames[] = {
13718 NULL
13719 };
13720
13721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
13722 {
13723 PyThreadState* __tstate = wxPyBeginAllowThreads();
13724 result = (wxANIHandler *)new wxANIHandler();
13725
13726 wxPyEndAllowThreads(__tstate);
13727 if (PyErr_Occurred()) SWIG_fail;
13728 }
13729 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
13730 return resultobj;
13731 fail:
13732 return NULL;
13733 }
13734
13735
13736 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
13737 PyObject *obj;
13738 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13739 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
13740 Py_INCREF(obj);
13741 return Py_BuildValue((char *)"");
13742 }
13743 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13744 PyObject *resultobj;
13745 wxPNGHandler *result;
13746 char *kwnames[] = {
13747 NULL
13748 };
13749
13750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
13751 {
13752 PyThreadState* __tstate = wxPyBeginAllowThreads();
13753 result = (wxPNGHandler *)new wxPNGHandler();
13754
13755 wxPyEndAllowThreads(__tstate);
13756 if (PyErr_Occurred()) SWIG_fail;
13757 }
13758 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
13759 return resultobj;
13760 fail:
13761 return NULL;
13762 }
13763
13764
13765 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
13766 PyObject *obj;
13767 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13768 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
13769 Py_INCREF(obj);
13770 return Py_BuildValue((char *)"");
13771 }
13772 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13773 PyObject *resultobj;
13774 wxGIFHandler *result;
13775 char *kwnames[] = {
13776 NULL
13777 };
13778
13779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
13780 {
13781 PyThreadState* __tstate = wxPyBeginAllowThreads();
13782 result = (wxGIFHandler *)new wxGIFHandler();
13783
13784 wxPyEndAllowThreads(__tstate);
13785 if (PyErr_Occurred()) SWIG_fail;
13786 }
13787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
13788 return resultobj;
13789 fail:
13790 return NULL;
13791 }
13792
13793
13794 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
13795 PyObject *obj;
13796 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13797 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
13798 Py_INCREF(obj);
13799 return Py_BuildValue((char *)"");
13800 }
13801 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13802 PyObject *resultobj;
13803 wxPCXHandler *result;
13804 char *kwnames[] = {
13805 NULL
13806 };
13807
13808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
13809 {
13810 PyThreadState* __tstate = wxPyBeginAllowThreads();
13811 result = (wxPCXHandler *)new wxPCXHandler();
13812
13813 wxPyEndAllowThreads(__tstate);
13814 if (PyErr_Occurred()) SWIG_fail;
13815 }
13816 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
13817 return resultobj;
13818 fail:
13819 return NULL;
13820 }
13821
13822
13823 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
13824 PyObject *obj;
13825 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13826 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
13827 Py_INCREF(obj);
13828 return Py_BuildValue((char *)"");
13829 }
13830 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13831 PyObject *resultobj;
13832 wxJPEGHandler *result;
13833 char *kwnames[] = {
13834 NULL
13835 };
13836
13837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
13838 {
13839 PyThreadState* __tstate = wxPyBeginAllowThreads();
13840 result = (wxJPEGHandler *)new wxJPEGHandler();
13841
13842 wxPyEndAllowThreads(__tstate);
13843 if (PyErr_Occurred()) SWIG_fail;
13844 }
13845 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
13846 return resultobj;
13847 fail:
13848 return NULL;
13849 }
13850
13851
13852 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
13853 PyObject *obj;
13854 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13855 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
13856 Py_INCREF(obj);
13857 return Py_BuildValue((char *)"");
13858 }
13859 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13860 PyObject *resultobj;
13861 wxPNMHandler *result;
13862 char *kwnames[] = {
13863 NULL
13864 };
13865
13866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
13867 {
13868 PyThreadState* __tstate = wxPyBeginAllowThreads();
13869 result = (wxPNMHandler *)new wxPNMHandler();
13870
13871 wxPyEndAllowThreads(__tstate);
13872 if (PyErr_Occurred()) SWIG_fail;
13873 }
13874 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
13875 return resultobj;
13876 fail:
13877 return NULL;
13878 }
13879
13880
13881 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
13882 PyObject *obj;
13883 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13884 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
13885 Py_INCREF(obj);
13886 return Py_BuildValue((char *)"");
13887 }
13888 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13889 PyObject *resultobj;
13890 wxXPMHandler *result;
13891 char *kwnames[] = {
13892 NULL
13893 };
13894
13895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
13896 {
13897 PyThreadState* __tstate = wxPyBeginAllowThreads();
13898 result = (wxXPMHandler *)new wxXPMHandler();
13899
13900 wxPyEndAllowThreads(__tstate);
13901 if (PyErr_Occurred()) SWIG_fail;
13902 }
13903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
13904 return resultobj;
13905 fail:
13906 return NULL;
13907 }
13908
13909
13910 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
13911 PyObject *obj;
13912 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13913 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
13914 Py_INCREF(obj);
13915 return Py_BuildValue((char *)"");
13916 }
13917 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13918 PyObject *resultobj;
13919 wxTIFFHandler *result;
13920 char *kwnames[] = {
13921 NULL
13922 };
13923
13924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
13925 {
13926 PyThreadState* __tstate = wxPyBeginAllowThreads();
13927 result = (wxTIFFHandler *)new wxTIFFHandler();
13928
13929 wxPyEndAllowThreads(__tstate);
13930 if (PyErr_Occurred()) SWIG_fail;
13931 }
13932 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
13933 return resultobj;
13934 fail:
13935 return NULL;
13936 }
13937
13938
13939 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
13940 PyObject *obj;
13941 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13942 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
13943 Py_INCREF(obj);
13944 return Py_BuildValue((char *)"");
13945 }
13946 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
13947 PyObject *resultobj;
13948 wxImage *arg1 = 0 ;
13949 wxImage *arg2 = 0 ;
13950 int arg3 = (int) 236 ;
13951 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
13952 bool result;
13953 PyObject * obj0 = 0 ;
13954 PyObject * obj1 = 0 ;
13955 PyObject * obj2 = 0 ;
13956 PyObject * obj3 = 0 ;
13957 char *kwnames[] = {
13958 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
13959 };
13960
13961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13962 {
13963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13964 if (SWIG_arg_fail(1)) SWIG_fail;
13965 if (arg1 == NULL) {
13966 SWIG_null_ref("wxImage");
13967 }
13968 if (SWIG_arg_fail(1)) SWIG_fail;
13969 }
13970 {
13971 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13972 if (SWIG_arg_fail(2)) SWIG_fail;
13973 if (arg2 == NULL) {
13974 SWIG_null_ref("wxImage");
13975 }
13976 if (SWIG_arg_fail(2)) SWIG_fail;
13977 }
13978 if (obj2) {
13979 {
13980 arg3 = (int)(SWIG_As_int(obj2));
13981 if (SWIG_arg_fail(3)) SWIG_fail;
13982 }
13983 }
13984 if (obj3) {
13985 {
13986 arg4 = (int)(SWIG_As_int(obj3));
13987 if (SWIG_arg_fail(4)) SWIG_fail;
13988 }
13989 }
13990 {
13991 PyThreadState* __tstate = wxPyBeginAllowThreads();
13992 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
13993
13994 wxPyEndAllowThreads(__tstate);
13995 if (PyErr_Occurred()) SWIG_fail;
13996 }
13997 {
13998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13999 }
14000 return resultobj;
14001 fail:
14002 return NULL;
14003 }
14004
14005
14006 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14007 PyObject *obj;
14008 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14009 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14010 Py_INCREF(obj);
14011 return Py_BuildValue((char *)"");
14012 }
14013 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14014 PyObject *resultobj;
14015 wxEvtHandler *result;
14016 char *kwnames[] = {
14017 NULL
14018 };
14019
14020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14021 {
14022 PyThreadState* __tstate = wxPyBeginAllowThreads();
14023 result = (wxEvtHandler *)new wxEvtHandler();
14024
14025 wxPyEndAllowThreads(__tstate);
14026 if (PyErr_Occurred()) SWIG_fail;
14027 }
14028 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14029 return resultobj;
14030 fail:
14031 return NULL;
14032 }
14033
14034
14035 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14036 PyObject *resultobj;
14037 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14038 wxEvtHandler *result;
14039 PyObject * obj0 = 0 ;
14040 char *kwnames[] = {
14041 (char *) "self", NULL
14042 };
14043
14044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14046 if (SWIG_arg_fail(1)) SWIG_fail;
14047 {
14048 PyThreadState* __tstate = wxPyBeginAllowThreads();
14049 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14050
14051 wxPyEndAllowThreads(__tstate);
14052 if (PyErr_Occurred()) SWIG_fail;
14053 }
14054 {
14055 resultobj = wxPyMake_wxObject(result, 0);
14056 }
14057 return resultobj;
14058 fail:
14059 return NULL;
14060 }
14061
14062
14063 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14064 PyObject *resultobj;
14065 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14066 wxEvtHandler *result;
14067 PyObject * obj0 = 0 ;
14068 char *kwnames[] = {
14069 (char *) "self", NULL
14070 };
14071
14072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14074 if (SWIG_arg_fail(1)) SWIG_fail;
14075 {
14076 PyThreadState* __tstate = wxPyBeginAllowThreads();
14077 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14078
14079 wxPyEndAllowThreads(__tstate);
14080 if (PyErr_Occurred()) SWIG_fail;
14081 }
14082 {
14083 resultobj = wxPyMake_wxObject(result, 0);
14084 }
14085 return resultobj;
14086 fail:
14087 return NULL;
14088 }
14089
14090
14091 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14092 PyObject *resultobj;
14093 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14094 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14095 PyObject * obj0 = 0 ;
14096 PyObject * obj1 = 0 ;
14097 char *kwnames[] = {
14098 (char *) "self",(char *) "handler", NULL
14099 };
14100
14101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14103 if (SWIG_arg_fail(1)) SWIG_fail;
14104 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14105 if (SWIG_arg_fail(2)) SWIG_fail;
14106 {
14107 PyThreadState* __tstate = wxPyBeginAllowThreads();
14108 (arg1)->SetNextHandler(arg2);
14109
14110 wxPyEndAllowThreads(__tstate);
14111 if (PyErr_Occurred()) SWIG_fail;
14112 }
14113 Py_INCREF(Py_None); resultobj = Py_None;
14114 return resultobj;
14115 fail:
14116 return NULL;
14117 }
14118
14119
14120 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14121 PyObject *resultobj;
14122 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14123 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14124 PyObject * obj0 = 0 ;
14125 PyObject * obj1 = 0 ;
14126 char *kwnames[] = {
14127 (char *) "self",(char *) "handler", NULL
14128 };
14129
14130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14132 if (SWIG_arg_fail(1)) SWIG_fail;
14133 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14134 if (SWIG_arg_fail(2)) SWIG_fail;
14135 {
14136 PyThreadState* __tstate = wxPyBeginAllowThreads();
14137 (arg1)->SetPreviousHandler(arg2);
14138
14139 wxPyEndAllowThreads(__tstate);
14140 if (PyErr_Occurred()) SWIG_fail;
14141 }
14142 Py_INCREF(Py_None); resultobj = Py_None;
14143 return resultobj;
14144 fail:
14145 return NULL;
14146 }
14147
14148
14149 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14150 PyObject *resultobj;
14151 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14152 bool result;
14153 PyObject * obj0 = 0 ;
14154 char *kwnames[] = {
14155 (char *) "self", NULL
14156 };
14157
14158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14160 if (SWIG_arg_fail(1)) SWIG_fail;
14161 {
14162 PyThreadState* __tstate = wxPyBeginAllowThreads();
14163 result = (bool)(arg1)->GetEvtHandlerEnabled();
14164
14165 wxPyEndAllowThreads(__tstate);
14166 if (PyErr_Occurred()) SWIG_fail;
14167 }
14168 {
14169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14170 }
14171 return resultobj;
14172 fail:
14173 return NULL;
14174 }
14175
14176
14177 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14178 PyObject *resultobj;
14179 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14180 bool arg2 ;
14181 PyObject * obj0 = 0 ;
14182 PyObject * obj1 = 0 ;
14183 char *kwnames[] = {
14184 (char *) "self",(char *) "enabled", NULL
14185 };
14186
14187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14189 if (SWIG_arg_fail(1)) SWIG_fail;
14190 {
14191 arg2 = (bool)(SWIG_As_bool(obj1));
14192 if (SWIG_arg_fail(2)) SWIG_fail;
14193 }
14194 {
14195 PyThreadState* __tstate = wxPyBeginAllowThreads();
14196 (arg1)->SetEvtHandlerEnabled(arg2);
14197
14198 wxPyEndAllowThreads(__tstate);
14199 if (PyErr_Occurred()) SWIG_fail;
14200 }
14201 Py_INCREF(Py_None); resultobj = Py_None;
14202 return resultobj;
14203 fail:
14204 return NULL;
14205 }
14206
14207
14208 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14209 PyObject *resultobj;
14210 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14211 wxEvent *arg2 = 0 ;
14212 bool result;
14213 PyObject * obj0 = 0 ;
14214 PyObject * obj1 = 0 ;
14215 char *kwnames[] = {
14216 (char *) "self",(char *) "event", NULL
14217 };
14218
14219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14221 if (SWIG_arg_fail(1)) SWIG_fail;
14222 {
14223 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14224 if (SWIG_arg_fail(2)) SWIG_fail;
14225 if (arg2 == NULL) {
14226 SWIG_null_ref("wxEvent");
14227 }
14228 if (SWIG_arg_fail(2)) SWIG_fail;
14229 }
14230 {
14231 PyThreadState* __tstate = wxPyBeginAllowThreads();
14232 result = (bool)(arg1)->ProcessEvent(*arg2);
14233
14234 wxPyEndAllowThreads(__tstate);
14235 if (PyErr_Occurred()) SWIG_fail;
14236 }
14237 {
14238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14239 }
14240 return resultobj;
14241 fail:
14242 return NULL;
14243 }
14244
14245
14246 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14247 PyObject *resultobj;
14248 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14249 wxEvent *arg2 = 0 ;
14250 PyObject * obj0 = 0 ;
14251 PyObject * obj1 = 0 ;
14252 char *kwnames[] = {
14253 (char *) "self",(char *) "event", NULL
14254 };
14255
14256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14258 if (SWIG_arg_fail(1)) SWIG_fail;
14259 {
14260 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14261 if (SWIG_arg_fail(2)) SWIG_fail;
14262 if (arg2 == NULL) {
14263 SWIG_null_ref("wxEvent");
14264 }
14265 if (SWIG_arg_fail(2)) SWIG_fail;
14266 }
14267 {
14268 PyThreadState* __tstate = wxPyBeginAllowThreads();
14269 (arg1)->AddPendingEvent(*arg2);
14270
14271 wxPyEndAllowThreads(__tstate);
14272 if (PyErr_Occurred()) SWIG_fail;
14273 }
14274 Py_INCREF(Py_None); resultobj = Py_None;
14275 return resultobj;
14276 fail:
14277 return NULL;
14278 }
14279
14280
14281 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14282 PyObject *resultobj;
14283 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14284 PyObject * obj0 = 0 ;
14285 char *kwnames[] = {
14286 (char *) "self", NULL
14287 };
14288
14289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14291 if (SWIG_arg_fail(1)) SWIG_fail;
14292 {
14293 PyThreadState* __tstate = wxPyBeginAllowThreads();
14294 (arg1)->ProcessPendingEvents();
14295
14296 wxPyEndAllowThreads(__tstate);
14297 if (PyErr_Occurred()) SWIG_fail;
14298 }
14299 Py_INCREF(Py_None); resultobj = Py_None;
14300 return resultobj;
14301 fail:
14302 return NULL;
14303 }
14304
14305
14306 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14307 PyObject *resultobj;
14308 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14309 int arg2 ;
14310 int arg3 ;
14311 int arg4 ;
14312 PyObject *arg5 = (PyObject *) 0 ;
14313 PyObject * obj0 = 0 ;
14314 PyObject * obj1 = 0 ;
14315 PyObject * obj2 = 0 ;
14316 PyObject * obj3 = 0 ;
14317 PyObject * obj4 = 0 ;
14318 char *kwnames[] = {
14319 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14320 };
14321
14322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14324 if (SWIG_arg_fail(1)) SWIG_fail;
14325 {
14326 arg2 = (int)(SWIG_As_int(obj1));
14327 if (SWIG_arg_fail(2)) SWIG_fail;
14328 }
14329 {
14330 arg3 = (int)(SWIG_As_int(obj2));
14331 if (SWIG_arg_fail(3)) SWIG_fail;
14332 }
14333 {
14334 arg4 = (int)(SWIG_As_int(obj3));
14335 if (SWIG_arg_fail(4)) SWIG_fail;
14336 }
14337 arg5 = obj4;
14338 {
14339 PyThreadState* __tstate = wxPyBeginAllowThreads();
14340 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14341
14342 wxPyEndAllowThreads(__tstate);
14343 if (PyErr_Occurred()) SWIG_fail;
14344 }
14345 Py_INCREF(Py_None); resultobj = Py_None;
14346 return resultobj;
14347 fail:
14348 return NULL;
14349 }
14350
14351
14352 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14353 PyObject *resultobj;
14354 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14355 int arg2 ;
14356 int arg3 = (int) -1 ;
14357 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14358 bool result;
14359 PyObject * obj0 = 0 ;
14360 PyObject * obj1 = 0 ;
14361 PyObject * obj2 = 0 ;
14362 PyObject * obj3 = 0 ;
14363 char *kwnames[] = {
14364 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14365 };
14366
14367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14369 if (SWIG_arg_fail(1)) SWIG_fail;
14370 {
14371 arg2 = (int)(SWIG_As_int(obj1));
14372 if (SWIG_arg_fail(2)) SWIG_fail;
14373 }
14374 if (obj2) {
14375 {
14376 arg3 = (int)(SWIG_As_int(obj2));
14377 if (SWIG_arg_fail(3)) SWIG_fail;
14378 }
14379 }
14380 if (obj3) {
14381 {
14382 arg4 = (wxEventType)(SWIG_As_int(obj3));
14383 if (SWIG_arg_fail(4)) SWIG_fail;
14384 }
14385 }
14386 {
14387 PyThreadState* __tstate = wxPyBeginAllowThreads();
14388 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14389
14390 wxPyEndAllowThreads(__tstate);
14391 if (PyErr_Occurred()) SWIG_fail;
14392 }
14393 {
14394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14395 }
14396 return resultobj;
14397 fail:
14398 return NULL;
14399 }
14400
14401
14402 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14403 PyObject *resultobj;
14404 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14405 PyObject *arg2 = (PyObject *) 0 ;
14406 bool arg3 = (bool) true ;
14407 PyObject * obj0 = 0 ;
14408 PyObject * obj1 = 0 ;
14409 PyObject * obj2 = 0 ;
14410 char *kwnames[] = {
14411 (char *) "self",(char *) "_self",(char *) "incref", NULL
14412 };
14413
14414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14416 if (SWIG_arg_fail(1)) SWIG_fail;
14417 arg2 = obj1;
14418 if (obj2) {
14419 {
14420 arg3 = (bool)(SWIG_As_bool(obj2));
14421 if (SWIG_arg_fail(3)) SWIG_fail;
14422 }
14423 }
14424 {
14425 PyThreadState* __tstate = wxPyBeginAllowThreads();
14426 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
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 * EvtHandler_swigregister(PyObject *, PyObject *args) {
14439 PyObject *obj;
14440 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14441 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14442 Py_INCREF(obj);
14443 return Py_BuildValue((char *)"");
14444 }
14445 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14446 PyObject *resultobj;
14447 wxEventType result;
14448 char *kwnames[] = {
14449 NULL
14450 };
14451
14452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14453 {
14454 PyThreadState* __tstate = wxPyBeginAllowThreads();
14455 result = (wxEventType)wxNewEventType();
14456
14457 wxPyEndAllowThreads(__tstate);
14458 if (PyErr_Occurred()) SWIG_fail;
14459 }
14460 {
14461 resultobj = SWIG_From_int((int)(result));
14462 }
14463 return resultobj;
14464 fail:
14465 return NULL;
14466 }
14467
14468
14469 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14470 PyObject *resultobj;
14471 wxEvent *arg1 = (wxEvent *) 0 ;
14472 PyObject * obj0 = 0 ;
14473 char *kwnames[] = {
14474 (char *) "self", NULL
14475 };
14476
14477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14479 if (SWIG_arg_fail(1)) SWIG_fail;
14480 {
14481 PyThreadState* __tstate = wxPyBeginAllowThreads();
14482 delete arg1;
14483
14484 wxPyEndAllowThreads(__tstate);
14485 if (PyErr_Occurred()) SWIG_fail;
14486 }
14487 Py_INCREF(Py_None); resultobj = Py_None;
14488 return resultobj;
14489 fail:
14490 return NULL;
14491 }
14492
14493
14494 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14495 PyObject *resultobj;
14496 wxEvent *arg1 = (wxEvent *) 0 ;
14497 wxEventType arg2 ;
14498 PyObject * obj0 = 0 ;
14499 PyObject * obj1 = 0 ;
14500 char *kwnames[] = {
14501 (char *) "self",(char *) "typ", NULL
14502 };
14503
14504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14506 if (SWIG_arg_fail(1)) SWIG_fail;
14507 {
14508 arg2 = (wxEventType)(SWIG_As_int(obj1));
14509 if (SWIG_arg_fail(2)) SWIG_fail;
14510 }
14511 {
14512 PyThreadState* __tstate = wxPyBeginAllowThreads();
14513 (arg1)->SetEventType(arg2);
14514
14515 wxPyEndAllowThreads(__tstate);
14516 if (PyErr_Occurred()) SWIG_fail;
14517 }
14518 Py_INCREF(Py_None); resultobj = Py_None;
14519 return resultobj;
14520 fail:
14521 return NULL;
14522 }
14523
14524
14525 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14526 PyObject *resultobj;
14527 wxEvent *arg1 = (wxEvent *) 0 ;
14528 wxEventType result;
14529 PyObject * obj0 = 0 ;
14530 char *kwnames[] = {
14531 (char *) "self", NULL
14532 };
14533
14534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14536 if (SWIG_arg_fail(1)) SWIG_fail;
14537 {
14538 PyThreadState* __tstate = wxPyBeginAllowThreads();
14539 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14540
14541 wxPyEndAllowThreads(__tstate);
14542 if (PyErr_Occurred()) SWIG_fail;
14543 }
14544 {
14545 resultobj = SWIG_From_int((int)(result));
14546 }
14547 return resultobj;
14548 fail:
14549 return NULL;
14550 }
14551
14552
14553 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14554 PyObject *resultobj;
14555 wxEvent *arg1 = (wxEvent *) 0 ;
14556 wxObject *result;
14557 PyObject * obj0 = 0 ;
14558 char *kwnames[] = {
14559 (char *) "self", NULL
14560 };
14561
14562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14564 if (SWIG_arg_fail(1)) SWIG_fail;
14565 {
14566 PyThreadState* __tstate = wxPyBeginAllowThreads();
14567 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14568
14569 wxPyEndAllowThreads(__tstate);
14570 if (PyErr_Occurred()) SWIG_fail;
14571 }
14572 {
14573 resultobj = wxPyMake_wxObject(result, 0);
14574 }
14575 return resultobj;
14576 fail:
14577 return NULL;
14578 }
14579
14580
14581 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14582 PyObject *resultobj;
14583 wxEvent *arg1 = (wxEvent *) 0 ;
14584 wxObject *arg2 = (wxObject *) 0 ;
14585 PyObject * obj0 = 0 ;
14586 PyObject * obj1 = 0 ;
14587 char *kwnames[] = {
14588 (char *) "self",(char *) "obj", NULL
14589 };
14590
14591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14593 if (SWIG_arg_fail(1)) SWIG_fail;
14594 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14595 if (SWIG_arg_fail(2)) SWIG_fail;
14596 {
14597 PyThreadState* __tstate = wxPyBeginAllowThreads();
14598 (arg1)->SetEventObject(arg2);
14599
14600 wxPyEndAllowThreads(__tstate);
14601 if (PyErr_Occurred()) SWIG_fail;
14602 }
14603 Py_INCREF(Py_None); resultobj = Py_None;
14604 return resultobj;
14605 fail:
14606 return NULL;
14607 }
14608
14609
14610 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14611 PyObject *resultobj;
14612 wxEvent *arg1 = (wxEvent *) 0 ;
14613 long result;
14614 PyObject * obj0 = 0 ;
14615 char *kwnames[] = {
14616 (char *) "self", NULL
14617 };
14618
14619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14621 if (SWIG_arg_fail(1)) SWIG_fail;
14622 {
14623 PyThreadState* __tstate = wxPyBeginAllowThreads();
14624 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14625
14626 wxPyEndAllowThreads(__tstate);
14627 if (PyErr_Occurred()) SWIG_fail;
14628 }
14629 {
14630 resultobj = SWIG_From_long((long)(result));
14631 }
14632 return resultobj;
14633 fail:
14634 return NULL;
14635 }
14636
14637
14638 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14639 PyObject *resultobj;
14640 wxEvent *arg1 = (wxEvent *) 0 ;
14641 long arg2 = (long) 0 ;
14642 PyObject * obj0 = 0 ;
14643 PyObject * obj1 = 0 ;
14644 char *kwnames[] = {
14645 (char *) "self",(char *) "ts", NULL
14646 };
14647
14648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14650 if (SWIG_arg_fail(1)) SWIG_fail;
14651 if (obj1) {
14652 {
14653 arg2 = (long)(SWIG_As_long(obj1));
14654 if (SWIG_arg_fail(2)) SWIG_fail;
14655 }
14656 }
14657 {
14658 PyThreadState* __tstate = wxPyBeginAllowThreads();
14659 (arg1)->SetTimestamp(arg2);
14660
14661 wxPyEndAllowThreads(__tstate);
14662 if (PyErr_Occurred()) SWIG_fail;
14663 }
14664 Py_INCREF(Py_None); resultobj = Py_None;
14665 return resultobj;
14666 fail:
14667 return NULL;
14668 }
14669
14670
14671 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14672 PyObject *resultobj;
14673 wxEvent *arg1 = (wxEvent *) 0 ;
14674 int result;
14675 PyObject * obj0 = 0 ;
14676 char *kwnames[] = {
14677 (char *) "self", NULL
14678 };
14679
14680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14682 if (SWIG_arg_fail(1)) SWIG_fail;
14683 {
14684 PyThreadState* __tstate = wxPyBeginAllowThreads();
14685 result = (int)((wxEvent const *)arg1)->GetId();
14686
14687 wxPyEndAllowThreads(__tstate);
14688 if (PyErr_Occurred()) SWIG_fail;
14689 }
14690 {
14691 resultobj = SWIG_From_int((int)(result));
14692 }
14693 return resultobj;
14694 fail:
14695 return NULL;
14696 }
14697
14698
14699 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14700 PyObject *resultobj;
14701 wxEvent *arg1 = (wxEvent *) 0 ;
14702 int arg2 ;
14703 PyObject * obj0 = 0 ;
14704 PyObject * obj1 = 0 ;
14705 char *kwnames[] = {
14706 (char *) "self",(char *) "Id", NULL
14707 };
14708
14709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
14710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14711 if (SWIG_arg_fail(1)) SWIG_fail;
14712 {
14713 arg2 = (int)(SWIG_As_int(obj1));
14714 if (SWIG_arg_fail(2)) SWIG_fail;
14715 }
14716 {
14717 PyThreadState* __tstate = wxPyBeginAllowThreads();
14718 (arg1)->SetId(arg2);
14719
14720 wxPyEndAllowThreads(__tstate);
14721 if (PyErr_Occurred()) SWIG_fail;
14722 }
14723 Py_INCREF(Py_None); resultobj = Py_None;
14724 return resultobj;
14725 fail:
14726 return NULL;
14727 }
14728
14729
14730 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14731 PyObject *resultobj;
14732 wxEvent *arg1 = (wxEvent *) 0 ;
14733 bool result;
14734 PyObject * obj0 = 0 ;
14735 char *kwnames[] = {
14736 (char *) "self", NULL
14737 };
14738
14739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
14740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14741 if (SWIG_arg_fail(1)) SWIG_fail;
14742 {
14743 PyThreadState* __tstate = wxPyBeginAllowThreads();
14744 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
14745
14746 wxPyEndAllowThreads(__tstate);
14747 if (PyErr_Occurred()) SWIG_fail;
14748 }
14749 {
14750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14751 }
14752 return resultobj;
14753 fail:
14754 return NULL;
14755 }
14756
14757
14758 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
14759 PyObject *resultobj;
14760 wxEvent *arg1 = (wxEvent *) 0 ;
14761 bool arg2 = (bool) true ;
14762 PyObject * obj0 = 0 ;
14763 PyObject * obj1 = 0 ;
14764 char *kwnames[] = {
14765 (char *) "self",(char *) "skip", NULL
14766 };
14767
14768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
14769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14770 if (SWIG_arg_fail(1)) SWIG_fail;
14771 if (obj1) {
14772 {
14773 arg2 = (bool)(SWIG_As_bool(obj1));
14774 if (SWIG_arg_fail(2)) SWIG_fail;
14775 }
14776 }
14777 {
14778 PyThreadState* __tstate = wxPyBeginAllowThreads();
14779 (arg1)->Skip(arg2);
14780
14781 wxPyEndAllowThreads(__tstate);
14782 if (PyErr_Occurred()) SWIG_fail;
14783 }
14784 Py_INCREF(Py_None); resultobj = Py_None;
14785 return resultobj;
14786 fail:
14787 return NULL;
14788 }
14789
14790
14791 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
14792 PyObject *resultobj;
14793 wxEvent *arg1 = (wxEvent *) 0 ;
14794 bool result;
14795 PyObject * obj0 = 0 ;
14796 char *kwnames[] = {
14797 (char *) "self", NULL
14798 };
14799
14800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
14801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14802 if (SWIG_arg_fail(1)) SWIG_fail;
14803 {
14804 PyThreadState* __tstate = wxPyBeginAllowThreads();
14805 result = (bool)((wxEvent const *)arg1)->GetSkipped();
14806
14807 wxPyEndAllowThreads(__tstate);
14808 if (PyErr_Occurred()) SWIG_fail;
14809 }
14810 {
14811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14812 }
14813 return resultobj;
14814 fail:
14815 return NULL;
14816 }
14817
14818
14819 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
14820 PyObject *resultobj;
14821 wxEvent *arg1 = (wxEvent *) 0 ;
14822 bool result;
14823 PyObject * obj0 = 0 ;
14824 char *kwnames[] = {
14825 (char *) "self", NULL
14826 };
14827
14828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
14829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14830 if (SWIG_arg_fail(1)) SWIG_fail;
14831 {
14832 PyThreadState* __tstate = wxPyBeginAllowThreads();
14833 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
14834
14835 wxPyEndAllowThreads(__tstate);
14836 if (PyErr_Occurred()) SWIG_fail;
14837 }
14838 {
14839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14840 }
14841 return resultobj;
14842 fail:
14843 return NULL;
14844 }
14845
14846
14847 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14848 PyObject *resultobj;
14849 wxEvent *arg1 = (wxEvent *) 0 ;
14850 int result;
14851 PyObject * obj0 = 0 ;
14852 char *kwnames[] = {
14853 (char *) "self", NULL
14854 };
14855
14856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
14857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14858 if (SWIG_arg_fail(1)) SWIG_fail;
14859 {
14860 PyThreadState* __tstate = wxPyBeginAllowThreads();
14861 result = (int)(arg1)->StopPropagation();
14862
14863 wxPyEndAllowThreads(__tstate);
14864 if (PyErr_Occurred()) SWIG_fail;
14865 }
14866 {
14867 resultobj = SWIG_From_int((int)(result));
14868 }
14869 return resultobj;
14870 fail:
14871 return NULL;
14872 }
14873
14874
14875 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14876 PyObject *resultobj;
14877 wxEvent *arg1 = (wxEvent *) 0 ;
14878 int arg2 ;
14879 PyObject * obj0 = 0 ;
14880 PyObject * obj1 = 0 ;
14881 char *kwnames[] = {
14882 (char *) "self",(char *) "propagationLevel", NULL
14883 };
14884
14885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
14886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14887 if (SWIG_arg_fail(1)) SWIG_fail;
14888 {
14889 arg2 = (int)(SWIG_As_int(obj1));
14890 if (SWIG_arg_fail(2)) SWIG_fail;
14891 }
14892 {
14893 PyThreadState* __tstate = wxPyBeginAllowThreads();
14894 (arg1)->ResumePropagation(arg2);
14895
14896 wxPyEndAllowThreads(__tstate);
14897 if (PyErr_Occurred()) SWIG_fail;
14898 }
14899 Py_INCREF(Py_None); resultobj = Py_None;
14900 return resultobj;
14901 fail:
14902 return NULL;
14903 }
14904
14905
14906 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
14907 PyObject *resultobj;
14908 wxEvent *arg1 = (wxEvent *) 0 ;
14909 wxEvent *result;
14910 PyObject * obj0 = 0 ;
14911 char *kwnames[] = {
14912 (char *) "self", NULL
14913 };
14914
14915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
14916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14917 if (SWIG_arg_fail(1)) SWIG_fail;
14918 {
14919 PyThreadState* __tstate = wxPyBeginAllowThreads();
14920 result = (wxEvent *)(arg1)->Clone();
14921
14922 wxPyEndAllowThreads(__tstate);
14923 if (PyErr_Occurred()) SWIG_fail;
14924 }
14925 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
14926 return resultobj;
14927 fail:
14928 return NULL;
14929 }
14930
14931
14932 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
14933 PyObject *obj;
14934 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14935 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
14936 Py_INCREF(obj);
14937 return Py_BuildValue((char *)"");
14938 }
14939 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14940 PyObject *resultobj;
14941 wxEvent *arg1 = 0 ;
14942 wxPropagationDisabler *result;
14943 PyObject * obj0 = 0 ;
14944 char *kwnames[] = {
14945 (char *) "event", NULL
14946 };
14947
14948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
14949 {
14950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14951 if (SWIG_arg_fail(1)) SWIG_fail;
14952 if (arg1 == NULL) {
14953 SWIG_null_ref("wxEvent");
14954 }
14955 if (SWIG_arg_fail(1)) SWIG_fail;
14956 }
14957 {
14958 PyThreadState* __tstate = wxPyBeginAllowThreads();
14959 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
14960
14961 wxPyEndAllowThreads(__tstate);
14962 if (PyErr_Occurred()) SWIG_fail;
14963 }
14964 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
14965 return resultobj;
14966 fail:
14967 return NULL;
14968 }
14969
14970
14971 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14972 PyObject *resultobj;
14973 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
14974 PyObject * obj0 = 0 ;
14975 char *kwnames[] = {
14976 (char *) "self", NULL
14977 };
14978
14979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
14980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
14981 if (SWIG_arg_fail(1)) SWIG_fail;
14982 {
14983 PyThreadState* __tstate = wxPyBeginAllowThreads();
14984 delete arg1;
14985
14986 wxPyEndAllowThreads(__tstate);
14987 if (PyErr_Occurred()) SWIG_fail;
14988 }
14989 Py_INCREF(Py_None); resultobj = Py_None;
14990 return resultobj;
14991 fail:
14992 return NULL;
14993 }
14994
14995
14996 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
14997 PyObject *obj;
14998 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14999 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15000 Py_INCREF(obj);
15001 return Py_BuildValue((char *)"");
15002 }
15003 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15004 PyObject *resultobj;
15005 wxEvent *arg1 = 0 ;
15006 wxPropagateOnce *result;
15007 PyObject * obj0 = 0 ;
15008 char *kwnames[] = {
15009 (char *) "event", NULL
15010 };
15011
15012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15013 {
15014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15015 if (SWIG_arg_fail(1)) SWIG_fail;
15016 if (arg1 == NULL) {
15017 SWIG_null_ref("wxEvent");
15018 }
15019 if (SWIG_arg_fail(1)) SWIG_fail;
15020 }
15021 {
15022 PyThreadState* __tstate = wxPyBeginAllowThreads();
15023 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15024
15025 wxPyEndAllowThreads(__tstate);
15026 if (PyErr_Occurred()) SWIG_fail;
15027 }
15028 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15029 return resultobj;
15030 fail:
15031 return NULL;
15032 }
15033
15034
15035 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15036 PyObject *resultobj;
15037 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15038 PyObject * obj0 = 0 ;
15039 char *kwnames[] = {
15040 (char *) "self", NULL
15041 };
15042
15043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15045 if (SWIG_arg_fail(1)) SWIG_fail;
15046 {
15047 PyThreadState* __tstate = wxPyBeginAllowThreads();
15048 delete arg1;
15049
15050 wxPyEndAllowThreads(__tstate);
15051 if (PyErr_Occurred()) SWIG_fail;
15052 }
15053 Py_INCREF(Py_None); resultobj = Py_None;
15054 return resultobj;
15055 fail:
15056 return NULL;
15057 }
15058
15059
15060 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15061 PyObject *obj;
15062 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15063 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15064 Py_INCREF(obj);
15065 return Py_BuildValue((char *)"");
15066 }
15067 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15068 PyObject *resultobj;
15069 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15070 int arg2 = (int) 0 ;
15071 wxCommandEvent *result;
15072 PyObject * obj0 = 0 ;
15073 PyObject * obj1 = 0 ;
15074 char *kwnames[] = {
15075 (char *) "commandType",(char *) "winid", NULL
15076 };
15077
15078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15079 if (obj0) {
15080 {
15081 arg1 = (wxEventType)(SWIG_As_int(obj0));
15082 if (SWIG_arg_fail(1)) SWIG_fail;
15083 }
15084 }
15085 if (obj1) {
15086 {
15087 arg2 = (int)(SWIG_As_int(obj1));
15088 if (SWIG_arg_fail(2)) SWIG_fail;
15089 }
15090 }
15091 {
15092 PyThreadState* __tstate = wxPyBeginAllowThreads();
15093 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15094
15095 wxPyEndAllowThreads(__tstate);
15096 if (PyErr_Occurred()) SWIG_fail;
15097 }
15098 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15099 return resultobj;
15100 fail:
15101 return NULL;
15102 }
15103
15104
15105 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15106 PyObject *resultobj;
15107 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15108 int result;
15109 PyObject * obj0 = 0 ;
15110 char *kwnames[] = {
15111 (char *) "self", NULL
15112 };
15113
15114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15116 if (SWIG_arg_fail(1)) SWIG_fail;
15117 {
15118 PyThreadState* __tstate = wxPyBeginAllowThreads();
15119 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15120
15121 wxPyEndAllowThreads(__tstate);
15122 if (PyErr_Occurred()) SWIG_fail;
15123 }
15124 {
15125 resultobj = SWIG_From_int((int)(result));
15126 }
15127 return resultobj;
15128 fail:
15129 return NULL;
15130 }
15131
15132
15133 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15134 PyObject *resultobj;
15135 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15136 wxString *arg2 = 0 ;
15137 bool temp2 = false ;
15138 PyObject * obj0 = 0 ;
15139 PyObject * obj1 = 0 ;
15140 char *kwnames[] = {
15141 (char *) "self",(char *) "s", NULL
15142 };
15143
15144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15146 if (SWIG_arg_fail(1)) SWIG_fail;
15147 {
15148 arg2 = wxString_in_helper(obj1);
15149 if (arg2 == NULL) SWIG_fail;
15150 temp2 = true;
15151 }
15152 {
15153 PyThreadState* __tstate = wxPyBeginAllowThreads();
15154 (arg1)->SetString((wxString const &)*arg2);
15155
15156 wxPyEndAllowThreads(__tstate);
15157 if (PyErr_Occurred()) SWIG_fail;
15158 }
15159 Py_INCREF(Py_None); resultobj = Py_None;
15160 {
15161 if (temp2)
15162 delete arg2;
15163 }
15164 return resultobj;
15165 fail:
15166 {
15167 if (temp2)
15168 delete arg2;
15169 }
15170 return NULL;
15171 }
15172
15173
15174 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15175 PyObject *resultobj;
15176 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15177 wxString result;
15178 PyObject * obj0 = 0 ;
15179 char *kwnames[] = {
15180 (char *) "self", NULL
15181 };
15182
15183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15185 if (SWIG_arg_fail(1)) SWIG_fail;
15186 {
15187 PyThreadState* __tstate = wxPyBeginAllowThreads();
15188 result = ((wxCommandEvent const *)arg1)->GetString();
15189
15190 wxPyEndAllowThreads(__tstate);
15191 if (PyErr_Occurred()) SWIG_fail;
15192 }
15193 {
15194 #if wxUSE_UNICODE
15195 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15196 #else
15197 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15198 #endif
15199 }
15200 return resultobj;
15201 fail:
15202 return NULL;
15203 }
15204
15205
15206 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15207 PyObject *resultobj;
15208 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15209 bool result;
15210 PyObject * obj0 = 0 ;
15211 char *kwnames[] = {
15212 (char *) "self", NULL
15213 };
15214
15215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15217 if (SWIG_arg_fail(1)) SWIG_fail;
15218 {
15219 PyThreadState* __tstate = wxPyBeginAllowThreads();
15220 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15221
15222 wxPyEndAllowThreads(__tstate);
15223 if (PyErr_Occurred()) SWIG_fail;
15224 }
15225 {
15226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15227 }
15228 return resultobj;
15229 fail:
15230 return NULL;
15231 }
15232
15233
15234 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15235 PyObject *resultobj;
15236 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15237 bool result;
15238 PyObject * obj0 = 0 ;
15239 char *kwnames[] = {
15240 (char *) "self", NULL
15241 };
15242
15243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15245 if (SWIG_arg_fail(1)) SWIG_fail;
15246 {
15247 PyThreadState* __tstate = wxPyBeginAllowThreads();
15248 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15249
15250 wxPyEndAllowThreads(__tstate);
15251 if (PyErr_Occurred()) SWIG_fail;
15252 }
15253 {
15254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15255 }
15256 return resultobj;
15257 fail:
15258 return NULL;
15259 }
15260
15261
15262 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15263 PyObject *resultobj;
15264 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15265 long arg2 ;
15266 PyObject * obj0 = 0 ;
15267 PyObject * obj1 = 0 ;
15268 char *kwnames[] = {
15269 (char *) "self",(char *) "extraLong", NULL
15270 };
15271
15272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15274 if (SWIG_arg_fail(1)) SWIG_fail;
15275 {
15276 arg2 = (long)(SWIG_As_long(obj1));
15277 if (SWIG_arg_fail(2)) SWIG_fail;
15278 }
15279 {
15280 PyThreadState* __tstate = wxPyBeginAllowThreads();
15281 (arg1)->SetExtraLong(arg2);
15282
15283 wxPyEndAllowThreads(__tstate);
15284 if (PyErr_Occurred()) SWIG_fail;
15285 }
15286 Py_INCREF(Py_None); resultobj = Py_None;
15287 return resultobj;
15288 fail:
15289 return NULL;
15290 }
15291
15292
15293 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15294 PyObject *resultobj;
15295 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15296 long result;
15297 PyObject * obj0 = 0 ;
15298 char *kwnames[] = {
15299 (char *) "self", NULL
15300 };
15301
15302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15304 if (SWIG_arg_fail(1)) SWIG_fail;
15305 {
15306 PyThreadState* __tstate = wxPyBeginAllowThreads();
15307 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15308
15309 wxPyEndAllowThreads(__tstate);
15310 if (PyErr_Occurred()) SWIG_fail;
15311 }
15312 {
15313 resultobj = SWIG_From_long((long)(result));
15314 }
15315 return resultobj;
15316 fail:
15317 return NULL;
15318 }
15319
15320
15321 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15322 PyObject *resultobj;
15323 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15324 int arg2 ;
15325 PyObject * obj0 = 0 ;
15326 PyObject * obj1 = 0 ;
15327 char *kwnames[] = {
15328 (char *) "self",(char *) "i", NULL
15329 };
15330
15331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15333 if (SWIG_arg_fail(1)) SWIG_fail;
15334 {
15335 arg2 = (int)(SWIG_As_int(obj1));
15336 if (SWIG_arg_fail(2)) SWIG_fail;
15337 }
15338 {
15339 PyThreadState* __tstate = wxPyBeginAllowThreads();
15340 (arg1)->SetInt(arg2);
15341
15342 wxPyEndAllowThreads(__tstate);
15343 if (PyErr_Occurred()) SWIG_fail;
15344 }
15345 Py_INCREF(Py_None); resultobj = Py_None;
15346 return resultobj;
15347 fail:
15348 return NULL;
15349 }
15350
15351
15352 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15353 PyObject *resultobj;
15354 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15355 long result;
15356 PyObject * obj0 = 0 ;
15357 char *kwnames[] = {
15358 (char *) "self", NULL
15359 };
15360
15361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15363 if (SWIG_arg_fail(1)) SWIG_fail;
15364 {
15365 PyThreadState* __tstate = wxPyBeginAllowThreads();
15366 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15367
15368 wxPyEndAllowThreads(__tstate);
15369 if (PyErr_Occurred()) SWIG_fail;
15370 }
15371 {
15372 resultobj = SWIG_From_long((long)(result));
15373 }
15374 return resultobj;
15375 fail:
15376 return NULL;
15377 }
15378
15379
15380 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15381 PyObject *resultobj;
15382 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15383 wxEvent *result;
15384 PyObject * obj0 = 0 ;
15385 char *kwnames[] = {
15386 (char *) "self", NULL
15387 };
15388
15389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15391 if (SWIG_arg_fail(1)) SWIG_fail;
15392 {
15393 PyThreadState* __tstate = wxPyBeginAllowThreads();
15394 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15395
15396 wxPyEndAllowThreads(__tstate);
15397 if (PyErr_Occurred()) SWIG_fail;
15398 }
15399 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15400 return resultobj;
15401 fail:
15402 return NULL;
15403 }
15404
15405
15406 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15407 PyObject *obj;
15408 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15409 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15410 Py_INCREF(obj);
15411 return Py_BuildValue((char *)"");
15412 }
15413 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15414 PyObject *resultobj;
15415 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15416 int arg2 = (int) 0 ;
15417 wxNotifyEvent *result;
15418 PyObject * obj0 = 0 ;
15419 PyObject * obj1 = 0 ;
15420 char *kwnames[] = {
15421 (char *) "commandType",(char *) "winid", NULL
15422 };
15423
15424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15425 if (obj0) {
15426 {
15427 arg1 = (wxEventType)(SWIG_As_int(obj0));
15428 if (SWIG_arg_fail(1)) SWIG_fail;
15429 }
15430 }
15431 if (obj1) {
15432 {
15433 arg2 = (int)(SWIG_As_int(obj1));
15434 if (SWIG_arg_fail(2)) SWIG_fail;
15435 }
15436 }
15437 {
15438 PyThreadState* __tstate = wxPyBeginAllowThreads();
15439 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15440
15441 wxPyEndAllowThreads(__tstate);
15442 if (PyErr_Occurred()) SWIG_fail;
15443 }
15444 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15445 return resultobj;
15446 fail:
15447 return NULL;
15448 }
15449
15450
15451 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15452 PyObject *resultobj;
15453 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15454 PyObject * obj0 = 0 ;
15455 char *kwnames[] = {
15456 (char *) "self", NULL
15457 };
15458
15459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15461 if (SWIG_arg_fail(1)) SWIG_fail;
15462 {
15463 PyThreadState* __tstate = wxPyBeginAllowThreads();
15464 (arg1)->Veto();
15465
15466 wxPyEndAllowThreads(__tstate);
15467 if (PyErr_Occurred()) SWIG_fail;
15468 }
15469 Py_INCREF(Py_None); resultobj = Py_None;
15470 return resultobj;
15471 fail:
15472 return NULL;
15473 }
15474
15475
15476 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15477 PyObject *resultobj;
15478 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15479 PyObject * obj0 = 0 ;
15480 char *kwnames[] = {
15481 (char *) "self", NULL
15482 };
15483
15484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15486 if (SWIG_arg_fail(1)) SWIG_fail;
15487 {
15488 PyThreadState* __tstate = wxPyBeginAllowThreads();
15489 (arg1)->Allow();
15490
15491 wxPyEndAllowThreads(__tstate);
15492 if (PyErr_Occurred()) SWIG_fail;
15493 }
15494 Py_INCREF(Py_None); resultobj = Py_None;
15495 return resultobj;
15496 fail:
15497 return NULL;
15498 }
15499
15500
15501 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15502 PyObject *resultobj;
15503 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15504 bool result;
15505 PyObject * obj0 = 0 ;
15506 char *kwnames[] = {
15507 (char *) "self", NULL
15508 };
15509
15510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15512 if (SWIG_arg_fail(1)) SWIG_fail;
15513 {
15514 PyThreadState* __tstate = wxPyBeginAllowThreads();
15515 result = (bool)(arg1)->IsAllowed();
15516
15517 wxPyEndAllowThreads(__tstate);
15518 if (PyErr_Occurred()) SWIG_fail;
15519 }
15520 {
15521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15522 }
15523 return resultobj;
15524 fail:
15525 return NULL;
15526 }
15527
15528
15529 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15530 PyObject *obj;
15531 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15532 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15533 Py_INCREF(obj);
15534 return Py_BuildValue((char *)"");
15535 }
15536 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15537 PyObject *resultobj;
15538 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15539 int arg2 = (int) 0 ;
15540 int arg3 = (int) 0 ;
15541 int arg4 = (int) 0 ;
15542 wxScrollEvent *result;
15543 PyObject * obj0 = 0 ;
15544 PyObject * obj1 = 0 ;
15545 PyObject * obj2 = 0 ;
15546 PyObject * obj3 = 0 ;
15547 char *kwnames[] = {
15548 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15549 };
15550
15551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15552 if (obj0) {
15553 {
15554 arg1 = (wxEventType)(SWIG_As_int(obj0));
15555 if (SWIG_arg_fail(1)) SWIG_fail;
15556 }
15557 }
15558 if (obj1) {
15559 {
15560 arg2 = (int)(SWIG_As_int(obj1));
15561 if (SWIG_arg_fail(2)) SWIG_fail;
15562 }
15563 }
15564 if (obj2) {
15565 {
15566 arg3 = (int)(SWIG_As_int(obj2));
15567 if (SWIG_arg_fail(3)) SWIG_fail;
15568 }
15569 }
15570 if (obj3) {
15571 {
15572 arg4 = (int)(SWIG_As_int(obj3));
15573 if (SWIG_arg_fail(4)) SWIG_fail;
15574 }
15575 }
15576 {
15577 PyThreadState* __tstate = wxPyBeginAllowThreads();
15578 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15579
15580 wxPyEndAllowThreads(__tstate);
15581 if (PyErr_Occurred()) SWIG_fail;
15582 }
15583 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15584 return resultobj;
15585 fail:
15586 return NULL;
15587 }
15588
15589
15590 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15591 PyObject *resultobj;
15592 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15593 int result;
15594 PyObject * obj0 = 0 ;
15595 char *kwnames[] = {
15596 (char *) "self", NULL
15597 };
15598
15599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15601 if (SWIG_arg_fail(1)) SWIG_fail;
15602 {
15603 PyThreadState* __tstate = wxPyBeginAllowThreads();
15604 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15605
15606 wxPyEndAllowThreads(__tstate);
15607 if (PyErr_Occurred()) SWIG_fail;
15608 }
15609 {
15610 resultobj = SWIG_From_int((int)(result));
15611 }
15612 return resultobj;
15613 fail:
15614 return NULL;
15615 }
15616
15617
15618 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15619 PyObject *resultobj;
15620 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15621 int result;
15622 PyObject * obj0 = 0 ;
15623 char *kwnames[] = {
15624 (char *) "self", NULL
15625 };
15626
15627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15629 if (SWIG_arg_fail(1)) SWIG_fail;
15630 {
15631 PyThreadState* __tstate = wxPyBeginAllowThreads();
15632 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15633
15634 wxPyEndAllowThreads(__tstate);
15635 if (PyErr_Occurred()) SWIG_fail;
15636 }
15637 {
15638 resultobj = SWIG_From_int((int)(result));
15639 }
15640 return resultobj;
15641 fail:
15642 return NULL;
15643 }
15644
15645
15646 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15647 PyObject *resultobj;
15648 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15649 int arg2 ;
15650 PyObject * obj0 = 0 ;
15651 PyObject * obj1 = 0 ;
15652 char *kwnames[] = {
15653 (char *) "self",(char *) "orient", NULL
15654 };
15655
15656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15658 if (SWIG_arg_fail(1)) SWIG_fail;
15659 {
15660 arg2 = (int)(SWIG_As_int(obj1));
15661 if (SWIG_arg_fail(2)) SWIG_fail;
15662 }
15663 {
15664 PyThreadState* __tstate = wxPyBeginAllowThreads();
15665 (arg1)->SetOrientation(arg2);
15666
15667 wxPyEndAllowThreads(__tstate);
15668 if (PyErr_Occurred()) SWIG_fail;
15669 }
15670 Py_INCREF(Py_None); resultobj = Py_None;
15671 return resultobj;
15672 fail:
15673 return NULL;
15674 }
15675
15676
15677 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15678 PyObject *resultobj;
15679 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15680 int arg2 ;
15681 PyObject * obj0 = 0 ;
15682 PyObject * obj1 = 0 ;
15683 char *kwnames[] = {
15684 (char *) "self",(char *) "pos", NULL
15685 };
15686
15687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15689 if (SWIG_arg_fail(1)) SWIG_fail;
15690 {
15691 arg2 = (int)(SWIG_As_int(obj1));
15692 if (SWIG_arg_fail(2)) SWIG_fail;
15693 }
15694 {
15695 PyThreadState* __tstate = wxPyBeginAllowThreads();
15696 (arg1)->SetPosition(arg2);
15697
15698 wxPyEndAllowThreads(__tstate);
15699 if (PyErr_Occurred()) SWIG_fail;
15700 }
15701 Py_INCREF(Py_None); resultobj = Py_None;
15702 return resultobj;
15703 fail:
15704 return NULL;
15705 }
15706
15707
15708 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
15709 PyObject *obj;
15710 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15711 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
15712 Py_INCREF(obj);
15713 return Py_BuildValue((char *)"");
15714 }
15715 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15716 PyObject *resultobj;
15717 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15718 int arg2 = (int) 0 ;
15719 int arg3 = (int) 0 ;
15720 wxScrollWinEvent *result;
15721 PyObject * obj0 = 0 ;
15722 PyObject * obj1 = 0 ;
15723 PyObject * obj2 = 0 ;
15724 char *kwnames[] = {
15725 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
15726 };
15727
15728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15729 if (obj0) {
15730 {
15731 arg1 = (wxEventType)(SWIG_As_int(obj0));
15732 if (SWIG_arg_fail(1)) SWIG_fail;
15733 }
15734 }
15735 if (obj1) {
15736 {
15737 arg2 = (int)(SWIG_As_int(obj1));
15738 if (SWIG_arg_fail(2)) SWIG_fail;
15739 }
15740 }
15741 if (obj2) {
15742 {
15743 arg3 = (int)(SWIG_As_int(obj2));
15744 if (SWIG_arg_fail(3)) SWIG_fail;
15745 }
15746 }
15747 {
15748 PyThreadState* __tstate = wxPyBeginAllowThreads();
15749 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
15750
15751 wxPyEndAllowThreads(__tstate);
15752 if (PyErr_Occurred()) SWIG_fail;
15753 }
15754 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
15755 return resultobj;
15756 fail:
15757 return NULL;
15758 }
15759
15760
15761 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15762 PyObject *resultobj;
15763 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15764 int result;
15765 PyObject * obj0 = 0 ;
15766 char *kwnames[] = {
15767 (char *) "self", NULL
15768 };
15769
15770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
15771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15772 if (SWIG_arg_fail(1)) SWIG_fail;
15773 {
15774 PyThreadState* __tstate = wxPyBeginAllowThreads();
15775 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
15776
15777 wxPyEndAllowThreads(__tstate);
15778 if (PyErr_Occurred()) SWIG_fail;
15779 }
15780 {
15781 resultobj = SWIG_From_int((int)(result));
15782 }
15783 return resultobj;
15784 fail:
15785 return NULL;
15786 }
15787
15788
15789 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15790 PyObject *resultobj;
15791 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15792 int result;
15793 PyObject * obj0 = 0 ;
15794 char *kwnames[] = {
15795 (char *) "self", NULL
15796 };
15797
15798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
15799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15800 if (SWIG_arg_fail(1)) SWIG_fail;
15801 {
15802 PyThreadState* __tstate = wxPyBeginAllowThreads();
15803 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
15804
15805 wxPyEndAllowThreads(__tstate);
15806 if (PyErr_Occurred()) SWIG_fail;
15807 }
15808 {
15809 resultobj = SWIG_From_int((int)(result));
15810 }
15811 return resultobj;
15812 fail:
15813 return NULL;
15814 }
15815
15816
15817 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15818 PyObject *resultobj;
15819 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15820 int arg2 ;
15821 PyObject * obj0 = 0 ;
15822 PyObject * obj1 = 0 ;
15823 char *kwnames[] = {
15824 (char *) "self",(char *) "orient", NULL
15825 };
15826
15827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15829 if (SWIG_arg_fail(1)) SWIG_fail;
15830 {
15831 arg2 = (int)(SWIG_As_int(obj1));
15832 if (SWIG_arg_fail(2)) SWIG_fail;
15833 }
15834 {
15835 PyThreadState* __tstate = wxPyBeginAllowThreads();
15836 (arg1)->SetOrientation(arg2);
15837
15838 wxPyEndAllowThreads(__tstate);
15839 if (PyErr_Occurred()) SWIG_fail;
15840 }
15841 Py_INCREF(Py_None); resultobj = Py_None;
15842 return resultobj;
15843 fail:
15844 return NULL;
15845 }
15846
15847
15848 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15849 PyObject *resultobj;
15850 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15851 int arg2 ;
15852 PyObject * obj0 = 0 ;
15853 PyObject * obj1 = 0 ;
15854 char *kwnames[] = {
15855 (char *) "self",(char *) "pos", NULL
15856 };
15857
15858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15860 if (SWIG_arg_fail(1)) SWIG_fail;
15861 {
15862 arg2 = (int)(SWIG_As_int(obj1));
15863 if (SWIG_arg_fail(2)) SWIG_fail;
15864 }
15865 {
15866 PyThreadState* __tstate = wxPyBeginAllowThreads();
15867 (arg1)->SetPosition(arg2);
15868
15869 wxPyEndAllowThreads(__tstate);
15870 if (PyErr_Occurred()) SWIG_fail;
15871 }
15872 Py_INCREF(Py_None); resultobj = Py_None;
15873 return resultobj;
15874 fail:
15875 return NULL;
15876 }
15877
15878
15879 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
15880 PyObject *obj;
15881 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15882 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
15883 Py_INCREF(obj);
15884 return Py_BuildValue((char *)"");
15885 }
15886 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15887 PyObject *resultobj;
15888 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15889 wxMouseEvent *result;
15890 PyObject * obj0 = 0 ;
15891 char *kwnames[] = {
15892 (char *) "mouseType", NULL
15893 };
15894
15895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
15896 if (obj0) {
15897 {
15898 arg1 = (wxEventType)(SWIG_As_int(obj0));
15899 if (SWIG_arg_fail(1)) SWIG_fail;
15900 }
15901 }
15902 {
15903 PyThreadState* __tstate = wxPyBeginAllowThreads();
15904 result = (wxMouseEvent *)new wxMouseEvent(arg1);
15905
15906 wxPyEndAllowThreads(__tstate);
15907 if (PyErr_Occurred()) SWIG_fail;
15908 }
15909 {
15910 resultobj = wxPyMake_wxObject(result, 1);
15911 }
15912 return resultobj;
15913 fail:
15914 return NULL;
15915 }
15916
15917
15918 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
15919 PyObject *resultobj;
15920 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15921 bool result;
15922 PyObject * obj0 = 0 ;
15923 char *kwnames[] = {
15924 (char *) "self", NULL
15925 };
15926
15927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
15932 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
15933
15934 wxPyEndAllowThreads(__tstate);
15935 if (PyErr_Occurred()) SWIG_fail;
15936 }
15937 {
15938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15939 }
15940 return resultobj;
15941 fail:
15942 return NULL;
15943 }
15944
15945
15946 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
15947 PyObject *resultobj;
15948 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15949 int arg2 = (int) wxMOUSE_BTN_ANY ;
15950 bool result;
15951 PyObject * obj0 = 0 ;
15952 PyObject * obj1 = 0 ;
15953 char *kwnames[] = {
15954 (char *) "self",(char *) "but", NULL
15955 };
15956
15957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
15958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15959 if (SWIG_arg_fail(1)) SWIG_fail;
15960 if (obj1) {
15961 {
15962 arg2 = (int)(SWIG_As_int(obj1));
15963 if (SWIG_arg_fail(2)) SWIG_fail;
15964 }
15965 }
15966 {
15967 PyThreadState* __tstate = wxPyBeginAllowThreads();
15968 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
15969
15970 wxPyEndAllowThreads(__tstate);
15971 if (PyErr_Occurred()) SWIG_fail;
15972 }
15973 {
15974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15975 }
15976 return resultobj;
15977 fail:
15978 return NULL;
15979 }
15980
15981
15982 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
15983 PyObject *resultobj;
15984 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15985 int arg2 = (int) wxMOUSE_BTN_ANY ;
15986 bool result;
15987 PyObject * obj0 = 0 ;
15988 PyObject * obj1 = 0 ;
15989 char *kwnames[] = {
15990 (char *) "self",(char *) "but", NULL
15991 };
15992
15993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
15994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15995 if (SWIG_arg_fail(1)) SWIG_fail;
15996 if (obj1) {
15997 {
15998 arg2 = (int)(SWIG_As_int(obj1));
15999 if (SWIG_arg_fail(2)) SWIG_fail;
16000 }
16001 }
16002 {
16003 PyThreadState* __tstate = wxPyBeginAllowThreads();
16004 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16005
16006 wxPyEndAllowThreads(__tstate);
16007 if (PyErr_Occurred()) SWIG_fail;
16008 }
16009 {
16010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16011 }
16012 return resultobj;
16013 fail:
16014 return NULL;
16015 }
16016
16017
16018 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16019 PyObject *resultobj;
16020 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16021 int arg2 = (int) wxMOUSE_BTN_ANY ;
16022 bool result;
16023 PyObject * obj0 = 0 ;
16024 PyObject * obj1 = 0 ;
16025 char *kwnames[] = {
16026 (char *) "self",(char *) "but", NULL
16027 };
16028
16029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16031 if (SWIG_arg_fail(1)) SWIG_fail;
16032 if (obj1) {
16033 {
16034 arg2 = (int)(SWIG_As_int(obj1));
16035 if (SWIG_arg_fail(2)) SWIG_fail;
16036 }
16037 }
16038 {
16039 PyThreadState* __tstate = wxPyBeginAllowThreads();
16040 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16041
16042 wxPyEndAllowThreads(__tstate);
16043 if (PyErr_Occurred()) SWIG_fail;
16044 }
16045 {
16046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16047 }
16048 return resultobj;
16049 fail:
16050 return NULL;
16051 }
16052
16053
16054 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16055 PyObject *resultobj;
16056 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16057 int arg2 ;
16058 bool result;
16059 PyObject * obj0 = 0 ;
16060 PyObject * obj1 = 0 ;
16061 char *kwnames[] = {
16062 (char *) "self",(char *) "but", NULL
16063 };
16064
16065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16067 if (SWIG_arg_fail(1)) SWIG_fail;
16068 {
16069 arg2 = (int)(SWIG_As_int(obj1));
16070 if (SWIG_arg_fail(2)) SWIG_fail;
16071 }
16072 {
16073 PyThreadState* __tstate = wxPyBeginAllowThreads();
16074 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16075
16076 wxPyEndAllowThreads(__tstate);
16077 if (PyErr_Occurred()) SWIG_fail;
16078 }
16079 {
16080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16081 }
16082 return resultobj;
16083 fail:
16084 return NULL;
16085 }
16086
16087
16088 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16089 PyObject *resultobj;
16090 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16091 int arg2 ;
16092 bool result;
16093 PyObject * obj0 = 0 ;
16094 PyObject * obj1 = 0 ;
16095 char *kwnames[] = {
16096 (char *) "self",(char *) "but", NULL
16097 };
16098
16099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
16104 if (SWIG_arg_fail(2)) SWIG_fail;
16105 }
16106 {
16107 PyThreadState* __tstate = wxPyBeginAllowThreads();
16108 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16109
16110 wxPyEndAllowThreads(__tstate);
16111 if (PyErr_Occurred()) SWIG_fail;
16112 }
16113 {
16114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16115 }
16116 return resultobj;
16117 fail:
16118 return NULL;
16119 }
16120
16121
16122 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16123 PyObject *resultobj;
16124 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16125 int result;
16126 PyObject * obj0 = 0 ;
16127 char *kwnames[] = {
16128 (char *) "self", NULL
16129 };
16130
16131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16133 if (SWIG_arg_fail(1)) SWIG_fail;
16134 {
16135 PyThreadState* __tstate = wxPyBeginAllowThreads();
16136 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16137
16138 wxPyEndAllowThreads(__tstate);
16139 if (PyErr_Occurred()) SWIG_fail;
16140 }
16141 {
16142 resultobj = SWIG_From_int((int)(result));
16143 }
16144 return resultobj;
16145 fail:
16146 return NULL;
16147 }
16148
16149
16150 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16151 PyObject *resultobj;
16152 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16153 bool result;
16154 PyObject * obj0 = 0 ;
16155 char *kwnames[] = {
16156 (char *) "self", NULL
16157 };
16158
16159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16161 if (SWIG_arg_fail(1)) SWIG_fail;
16162 {
16163 PyThreadState* __tstate = wxPyBeginAllowThreads();
16164 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16165
16166 wxPyEndAllowThreads(__tstate);
16167 if (PyErr_Occurred()) SWIG_fail;
16168 }
16169 {
16170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16171 }
16172 return resultobj;
16173 fail:
16174 return NULL;
16175 }
16176
16177
16178 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16179 PyObject *resultobj;
16180 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16181 bool result;
16182 PyObject * obj0 = 0 ;
16183 char *kwnames[] = {
16184 (char *) "self", NULL
16185 };
16186
16187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16189 if (SWIG_arg_fail(1)) SWIG_fail;
16190 {
16191 PyThreadState* __tstate = wxPyBeginAllowThreads();
16192 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16193
16194 wxPyEndAllowThreads(__tstate);
16195 if (PyErr_Occurred()) SWIG_fail;
16196 }
16197 {
16198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16199 }
16200 return resultobj;
16201 fail:
16202 return NULL;
16203 }
16204
16205
16206 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16207 PyObject *resultobj;
16208 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16209 bool result;
16210 PyObject * obj0 = 0 ;
16211 char *kwnames[] = {
16212 (char *) "self", NULL
16213 };
16214
16215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16217 if (SWIG_arg_fail(1)) SWIG_fail;
16218 {
16219 PyThreadState* __tstate = wxPyBeginAllowThreads();
16220 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16221
16222 wxPyEndAllowThreads(__tstate);
16223 if (PyErr_Occurred()) SWIG_fail;
16224 }
16225 {
16226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16227 }
16228 return resultobj;
16229 fail:
16230 return NULL;
16231 }
16232
16233
16234 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16235 PyObject *resultobj;
16236 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16237 bool result;
16238 PyObject * obj0 = 0 ;
16239 char *kwnames[] = {
16240 (char *) "self", NULL
16241 };
16242
16243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16245 if (SWIG_arg_fail(1)) SWIG_fail;
16246 {
16247 PyThreadState* __tstate = wxPyBeginAllowThreads();
16248 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16249
16250 wxPyEndAllowThreads(__tstate);
16251 if (PyErr_Occurred()) SWIG_fail;
16252 }
16253 {
16254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16255 }
16256 return resultobj;
16257 fail:
16258 return NULL;
16259 }
16260
16261
16262 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16263 PyObject *resultobj;
16264 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16265 bool result;
16266 PyObject * obj0 = 0 ;
16267 char *kwnames[] = {
16268 (char *) "self", NULL
16269 };
16270
16271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16273 if (SWIG_arg_fail(1)) SWIG_fail;
16274 {
16275 PyThreadState* __tstate = wxPyBeginAllowThreads();
16276 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16277
16278 wxPyEndAllowThreads(__tstate);
16279 if (PyErr_Occurred()) SWIG_fail;
16280 }
16281 {
16282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16283 }
16284 return resultobj;
16285 fail:
16286 return NULL;
16287 }
16288
16289
16290 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16291 PyObject *resultobj;
16292 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16293 bool result;
16294 PyObject * obj0 = 0 ;
16295 char *kwnames[] = {
16296 (char *) "self", NULL
16297 };
16298
16299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16301 if (SWIG_arg_fail(1)) SWIG_fail;
16302 {
16303 PyThreadState* __tstate = wxPyBeginAllowThreads();
16304 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16305
16306 wxPyEndAllowThreads(__tstate);
16307 if (PyErr_Occurred()) SWIG_fail;
16308 }
16309 {
16310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16311 }
16312 return resultobj;
16313 fail:
16314 return NULL;
16315 }
16316
16317
16318 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16319 PyObject *resultobj;
16320 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16321 bool result;
16322 PyObject * obj0 = 0 ;
16323 char *kwnames[] = {
16324 (char *) "self", NULL
16325 };
16326
16327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16329 if (SWIG_arg_fail(1)) SWIG_fail;
16330 {
16331 PyThreadState* __tstate = wxPyBeginAllowThreads();
16332 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16333
16334 wxPyEndAllowThreads(__tstate);
16335 if (PyErr_Occurred()) SWIG_fail;
16336 }
16337 {
16338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16339 }
16340 return resultobj;
16341 fail:
16342 return NULL;
16343 }
16344
16345
16346 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16347 PyObject *resultobj;
16348 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16349 bool result;
16350 PyObject * obj0 = 0 ;
16351 char *kwnames[] = {
16352 (char *) "self", NULL
16353 };
16354
16355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16357 if (SWIG_arg_fail(1)) SWIG_fail;
16358 {
16359 PyThreadState* __tstate = wxPyBeginAllowThreads();
16360 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16361
16362 wxPyEndAllowThreads(__tstate);
16363 if (PyErr_Occurred()) SWIG_fail;
16364 }
16365 {
16366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16367 }
16368 return resultobj;
16369 fail:
16370 return NULL;
16371 }
16372
16373
16374 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16375 PyObject *resultobj;
16376 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16377 bool result;
16378 PyObject * obj0 = 0 ;
16379 char *kwnames[] = {
16380 (char *) "self", NULL
16381 };
16382
16383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16385 if (SWIG_arg_fail(1)) SWIG_fail;
16386 {
16387 PyThreadState* __tstate = wxPyBeginAllowThreads();
16388 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16389
16390 wxPyEndAllowThreads(__tstate);
16391 if (PyErr_Occurred()) SWIG_fail;
16392 }
16393 {
16394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16395 }
16396 return resultobj;
16397 fail:
16398 return NULL;
16399 }
16400
16401
16402 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16403 PyObject *resultobj;
16404 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16405 bool result;
16406 PyObject * obj0 = 0 ;
16407 char *kwnames[] = {
16408 (char *) "self", NULL
16409 };
16410
16411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16413 if (SWIG_arg_fail(1)) SWIG_fail;
16414 {
16415 PyThreadState* __tstate = wxPyBeginAllowThreads();
16416 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16417
16418 wxPyEndAllowThreads(__tstate);
16419 if (PyErr_Occurred()) SWIG_fail;
16420 }
16421 {
16422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16423 }
16424 return resultobj;
16425 fail:
16426 return NULL;
16427 }
16428
16429
16430 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16431 PyObject *resultobj;
16432 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16433 bool result;
16434 PyObject * obj0 = 0 ;
16435 char *kwnames[] = {
16436 (char *) "self", NULL
16437 };
16438
16439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16441 if (SWIG_arg_fail(1)) SWIG_fail;
16442 {
16443 PyThreadState* __tstate = wxPyBeginAllowThreads();
16444 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16445
16446 wxPyEndAllowThreads(__tstate);
16447 if (PyErr_Occurred()) SWIG_fail;
16448 }
16449 {
16450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16451 }
16452 return resultobj;
16453 fail:
16454 return NULL;
16455 }
16456
16457
16458 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16459 PyObject *resultobj;
16460 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16461 bool result;
16462 PyObject * obj0 = 0 ;
16463 char *kwnames[] = {
16464 (char *) "self", NULL
16465 };
16466
16467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16469 if (SWIG_arg_fail(1)) SWIG_fail;
16470 {
16471 PyThreadState* __tstate = wxPyBeginAllowThreads();
16472 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16473
16474 wxPyEndAllowThreads(__tstate);
16475 if (PyErr_Occurred()) SWIG_fail;
16476 }
16477 {
16478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16479 }
16480 return resultobj;
16481 fail:
16482 return NULL;
16483 }
16484
16485
16486 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16487 PyObject *resultobj;
16488 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16489 bool result;
16490 PyObject * obj0 = 0 ;
16491 char *kwnames[] = {
16492 (char *) "self", NULL
16493 };
16494
16495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16497 if (SWIG_arg_fail(1)) SWIG_fail;
16498 {
16499 PyThreadState* __tstate = wxPyBeginAllowThreads();
16500 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16501
16502 wxPyEndAllowThreads(__tstate);
16503 if (PyErr_Occurred()) SWIG_fail;
16504 }
16505 {
16506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16507 }
16508 return resultobj;
16509 fail:
16510 return NULL;
16511 }
16512
16513
16514 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16515 PyObject *resultobj;
16516 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16517 bool result;
16518 PyObject * obj0 = 0 ;
16519 char *kwnames[] = {
16520 (char *) "self", NULL
16521 };
16522
16523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16525 if (SWIG_arg_fail(1)) SWIG_fail;
16526 {
16527 PyThreadState* __tstate = wxPyBeginAllowThreads();
16528 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16529
16530 wxPyEndAllowThreads(__tstate);
16531 if (PyErr_Occurred()) SWIG_fail;
16532 }
16533 {
16534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16535 }
16536 return resultobj;
16537 fail:
16538 return NULL;
16539 }
16540
16541
16542 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16543 PyObject *resultobj;
16544 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16545 bool result;
16546 PyObject * obj0 = 0 ;
16547 char *kwnames[] = {
16548 (char *) "self", NULL
16549 };
16550
16551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16553 if (SWIG_arg_fail(1)) SWIG_fail;
16554 {
16555 PyThreadState* __tstate = wxPyBeginAllowThreads();
16556 result = (bool)(arg1)->LeftIsDown();
16557
16558 wxPyEndAllowThreads(__tstate);
16559 if (PyErr_Occurred()) SWIG_fail;
16560 }
16561 {
16562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16563 }
16564 return resultobj;
16565 fail:
16566 return NULL;
16567 }
16568
16569
16570 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16571 PyObject *resultobj;
16572 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16573 bool result;
16574 PyObject * obj0 = 0 ;
16575 char *kwnames[] = {
16576 (char *) "self", NULL
16577 };
16578
16579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16581 if (SWIG_arg_fail(1)) SWIG_fail;
16582 {
16583 PyThreadState* __tstate = wxPyBeginAllowThreads();
16584 result = (bool)(arg1)->MiddleIsDown();
16585
16586 wxPyEndAllowThreads(__tstate);
16587 if (PyErr_Occurred()) SWIG_fail;
16588 }
16589 {
16590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16591 }
16592 return resultobj;
16593 fail:
16594 return NULL;
16595 }
16596
16597
16598 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16599 PyObject *resultobj;
16600 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16601 bool result;
16602 PyObject * obj0 = 0 ;
16603 char *kwnames[] = {
16604 (char *) "self", NULL
16605 };
16606
16607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16609 if (SWIG_arg_fail(1)) SWIG_fail;
16610 {
16611 PyThreadState* __tstate = wxPyBeginAllowThreads();
16612 result = (bool)(arg1)->RightIsDown();
16613
16614 wxPyEndAllowThreads(__tstate);
16615 if (PyErr_Occurred()) SWIG_fail;
16616 }
16617 {
16618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16619 }
16620 return resultobj;
16621 fail:
16622 return NULL;
16623 }
16624
16625
16626 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16627 PyObject *resultobj;
16628 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16629 bool result;
16630 PyObject * obj0 = 0 ;
16631 char *kwnames[] = {
16632 (char *) "self", NULL
16633 };
16634
16635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16637 if (SWIG_arg_fail(1)) SWIG_fail;
16638 {
16639 PyThreadState* __tstate = wxPyBeginAllowThreads();
16640 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16641
16642 wxPyEndAllowThreads(__tstate);
16643 if (PyErr_Occurred()) SWIG_fail;
16644 }
16645 {
16646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16647 }
16648 return resultobj;
16649 fail:
16650 return NULL;
16651 }
16652
16653
16654 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16655 PyObject *resultobj;
16656 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16657 bool result;
16658 PyObject * obj0 = 0 ;
16659 char *kwnames[] = {
16660 (char *) "self", NULL
16661 };
16662
16663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16665 if (SWIG_arg_fail(1)) SWIG_fail;
16666 {
16667 PyThreadState* __tstate = wxPyBeginAllowThreads();
16668 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16669
16670 wxPyEndAllowThreads(__tstate);
16671 if (PyErr_Occurred()) SWIG_fail;
16672 }
16673 {
16674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16675 }
16676 return resultobj;
16677 fail:
16678 return NULL;
16679 }
16680
16681
16682 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16683 PyObject *resultobj;
16684 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16685 bool result;
16686 PyObject * obj0 = 0 ;
16687 char *kwnames[] = {
16688 (char *) "self", NULL
16689 };
16690
16691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16693 if (SWIG_arg_fail(1)) SWIG_fail;
16694 {
16695 PyThreadState* __tstate = wxPyBeginAllowThreads();
16696 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16697
16698 wxPyEndAllowThreads(__tstate);
16699 if (PyErr_Occurred()) SWIG_fail;
16700 }
16701 {
16702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16703 }
16704 return resultobj;
16705 fail:
16706 return NULL;
16707 }
16708
16709
16710 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
16711 PyObject *resultobj;
16712 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16713 bool result;
16714 PyObject * obj0 = 0 ;
16715 char *kwnames[] = {
16716 (char *) "self", NULL
16717 };
16718
16719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
16720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16721 if (SWIG_arg_fail(1)) SWIG_fail;
16722 {
16723 PyThreadState* __tstate = wxPyBeginAllowThreads();
16724 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
16725
16726 wxPyEndAllowThreads(__tstate);
16727 if (PyErr_Occurred()) SWIG_fail;
16728 }
16729 {
16730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16731 }
16732 return resultobj;
16733 fail:
16734 return NULL;
16735 }
16736
16737
16738 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16739 PyObject *resultobj;
16740 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16741 wxPoint result;
16742 PyObject * obj0 = 0 ;
16743 char *kwnames[] = {
16744 (char *) "self", NULL
16745 };
16746
16747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
16748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16749 if (SWIG_arg_fail(1)) SWIG_fail;
16750 {
16751 PyThreadState* __tstate = wxPyBeginAllowThreads();
16752 result = (arg1)->GetPosition();
16753
16754 wxPyEndAllowThreads(__tstate);
16755 if (PyErr_Occurred()) SWIG_fail;
16756 }
16757 {
16758 wxPoint * resultptr;
16759 resultptr = new wxPoint((wxPoint &)(result));
16760 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16761 }
16762 return resultobj;
16763 fail:
16764 return NULL;
16765 }
16766
16767
16768 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16769 PyObject *resultobj;
16770 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16771 long *arg2 = (long *) 0 ;
16772 long *arg3 = (long *) 0 ;
16773 long temp2 ;
16774 int res2 = 0 ;
16775 long temp3 ;
16776 int res3 = 0 ;
16777 PyObject * obj0 = 0 ;
16778 char *kwnames[] = {
16779 (char *) "self", NULL
16780 };
16781
16782 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16783 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
16785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16786 if (SWIG_arg_fail(1)) SWIG_fail;
16787 {
16788 PyThreadState* __tstate = wxPyBeginAllowThreads();
16789 (arg1)->GetPosition(arg2,arg3);
16790
16791 wxPyEndAllowThreads(__tstate);
16792 if (PyErr_Occurred()) SWIG_fail;
16793 }
16794 Py_INCREF(Py_None); resultobj = Py_None;
16795 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16796 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
16797 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16798 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
16799 return resultobj;
16800 fail:
16801 return NULL;
16802 }
16803
16804
16805 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16806 PyObject *resultobj;
16807 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16808 wxDC *arg2 = 0 ;
16809 wxPoint result;
16810 PyObject * obj0 = 0 ;
16811 PyObject * obj1 = 0 ;
16812 char *kwnames[] = {
16813 (char *) "self",(char *) "dc", NULL
16814 };
16815
16816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
16817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16818 if (SWIG_arg_fail(1)) SWIG_fail;
16819 {
16820 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16821 if (SWIG_arg_fail(2)) SWIG_fail;
16822 if (arg2 == NULL) {
16823 SWIG_null_ref("wxDC");
16824 }
16825 if (SWIG_arg_fail(2)) SWIG_fail;
16826 }
16827 {
16828 PyThreadState* __tstate = wxPyBeginAllowThreads();
16829 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
16830
16831 wxPyEndAllowThreads(__tstate);
16832 if (PyErr_Occurred()) SWIG_fail;
16833 }
16834 {
16835 wxPoint * resultptr;
16836 resultptr = new wxPoint((wxPoint &)(result));
16837 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16838 }
16839 return resultobj;
16840 fail:
16841 return NULL;
16842 }
16843
16844
16845 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
16846 PyObject *resultobj;
16847 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16848 int result;
16849 PyObject * obj0 = 0 ;
16850 char *kwnames[] = {
16851 (char *) "self", NULL
16852 };
16853
16854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
16855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16856 if (SWIG_arg_fail(1)) SWIG_fail;
16857 {
16858 PyThreadState* __tstate = wxPyBeginAllowThreads();
16859 result = (int)((wxMouseEvent const *)arg1)->GetX();
16860
16861 wxPyEndAllowThreads(__tstate);
16862 if (PyErr_Occurred()) SWIG_fail;
16863 }
16864 {
16865 resultobj = SWIG_From_int((int)(result));
16866 }
16867 return resultobj;
16868 fail:
16869 return NULL;
16870 }
16871
16872
16873 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
16874 PyObject *resultobj;
16875 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16876 int result;
16877 PyObject * obj0 = 0 ;
16878 char *kwnames[] = {
16879 (char *) "self", NULL
16880 };
16881
16882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
16883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16884 if (SWIG_arg_fail(1)) SWIG_fail;
16885 {
16886 PyThreadState* __tstate = wxPyBeginAllowThreads();
16887 result = (int)((wxMouseEvent const *)arg1)->GetY();
16888
16889 wxPyEndAllowThreads(__tstate);
16890 if (PyErr_Occurred()) SWIG_fail;
16891 }
16892 {
16893 resultobj = SWIG_From_int((int)(result));
16894 }
16895 return resultobj;
16896 fail:
16897 return NULL;
16898 }
16899
16900
16901 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
16902 PyObject *resultobj;
16903 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16904 int result;
16905 PyObject * obj0 = 0 ;
16906 char *kwnames[] = {
16907 (char *) "self", NULL
16908 };
16909
16910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
16911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16912 if (SWIG_arg_fail(1)) SWIG_fail;
16913 {
16914 PyThreadState* __tstate = wxPyBeginAllowThreads();
16915 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
16916
16917 wxPyEndAllowThreads(__tstate);
16918 if (PyErr_Occurred()) SWIG_fail;
16919 }
16920 {
16921 resultobj = SWIG_From_int((int)(result));
16922 }
16923 return resultobj;
16924 fail:
16925 return NULL;
16926 }
16927
16928
16929 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
16930 PyObject *resultobj;
16931 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16932 int result;
16933 PyObject * obj0 = 0 ;
16934 char *kwnames[] = {
16935 (char *) "self", NULL
16936 };
16937
16938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
16939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16940 if (SWIG_arg_fail(1)) SWIG_fail;
16941 {
16942 PyThreadState* __tstate = wxPyBeginAllowThreads();
16943 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
16944
16945 wxPyEndAllowThreads(__tstate);
16946 if (PyErr_Occurred()) SWIG_fail;
16947 }
16948 {
16949 resultobj = SWIG_From_int((int)(result));
16950 }
16951 return resultobj;
16952 fail:
16953 return NULL;
16954 }
16955
16956
16957 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
16958 PyObject *resultobj;
16959 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16960 int result;
16961 PyObject * obj0 = 0 ;
16962 char *kwnames[] = {
16963 (char *) "self", NULL
16964 };
16965
16966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
16967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16968 if (SWIG_arg_fail(1)) SWIG_fail;
16969 {
16970 PyThreadState* __tstate = wxPyBeginAllowThreads();
16971 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
16972
16973 wxPyEndAllowThreads(__tstate);
16974 if (PyErr_Occurred()) SWIG_fail;
16975 }
16976 {
16977 resultobj = SWIG_From_int((int)(result));
16978 }
16979 return resultobj;
16980 fail:
16981 return NULL;
16982 }
16983
16984
16985 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
16986 PyObject *resultobj;
16987 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16988 bool result;
16989 PyObject * obj0 = 0 ;
16990 char *kwnames[] = {
16991 (char *) "self", NULL
16992 };
16993
16994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
16995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16996 if (SWIG_arg_fail(1)) SWIG_fail;
16997 {
16998 PyThreadState* __tstate = wxPyBeginAllowThreads();
16999 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17000
17001 wxPyEndAllowThreads(__tstate);
17002 if (PyErr_Occurred()) SWIG_fail;
17003 }
17004 {
17005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17006 }
17007 return resultobj;
17008 fail:
17009 return NULL;
17010 }
17011
17012
17013 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17014 PyObject *resultobj;
17015 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17016 int arg2 ;
17017 PyObject * obj0 = 0 ;
17018 PyObject * obj1 = 0 ;
17019 char *kwnames[] = {
17020 (char *) "self",(char *) "m_x", NULL
17021 };
17022
17023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) 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 {
17027 arg2 = (int)(SWIG_As_int(obj1));
17028 if (SWIG_arg_fail(2)) SWIG_fail;
17029 }
17030 if (arg1) (arg1)->m_x = arg2;
17031
17032 Py_INCREF(Py_None); resultobj = Py_None;
17033 return resultobj;
17034 fail:
17035 return NULL;
17036 }
17037
17038
17039 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17040 PyObject *resultobj;
17041 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17042 int result;
17043 PyObject * obj0 = 0 ;
17044 char *kwnames[] = {
17045 (char *) "self", NULL
17046 };
17047
17048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17050 if (SWIG_arg_fail(1)) SWIG_fail;
17051 result = (int) ((arg1)->m_x);
17052
17053 {
17054 resultobj = SWIG_From_int((int)(result));
17055 }
17056 return resultobj;
17057 fail:
17058 return NULL;
17059 }
17060
17061
17062 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17063 PyObject *resultobj;
17064 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17065 int arg2 ;
17066 PyObject * obj0 = 0 ;
17067 PyObject * obj1 = 0 ;
17068 char *kwnames[] = {
17069 (char *) "self",(char *) "m_y", NULL
17070 };
17071
17072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) 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 {
17076 arg2 = (int)(SWIG_As_int(obj1));
17077 if (SWIG_arg_fail(2)) SWIG_fail;
17078 }
17079 if (arg1) (arg1)->m_y = arg2;
17080
17081 Py_INCREF(Py_None); resultobj = Py_None;
17082 return resultobj;
17083 fail:
17084 return NULL;
17085 }
17086
17087
17088 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17089 PyObject *resultobj;
17090 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17091 int result;
17092 PyObject * obj0 = 0 ;
17093 char *kwnames[] = {
17094 (char *) "self", NULL
17095 };
17096
17097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17099 if (SWIG_arg_fail(1)) SWIG_fail;
17100 result = (int) ((arg1)->m_y);
17101
17102 {
17103 resultobj = SWIG_From_int((int)(result));
17104 }
17105 return resultobj;
17106 fail:
17107 return NULL;
17108 }
17109
17110
17111 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17112 PyObject *resultobj;
17113 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17114 bool arg2 ;
17115 PyObject * obj0 = 0 ;
17116 PyObject * obj1 = 0 ;
17117 char *kwnames[] = {
17118 (char *) "self",(char *) "m_leftDown", NULL
17119 };
17120
17121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) 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 {
17125 arg2 = (bool)(SWIG_As_bool(obj1));
17126 if (SWIG_arg_fail(2)) SWIG_fail;
17127 }
17128 if (arg1) (arg1)->m_leftDown = arg2;
17129
17130 Py_INCREF(Py_None); resultobj = Py_None;
17131 return resultobj;
17132 fail:
17133 return NULL;
17134 }
17135
17136
17137 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17138 PyObject *resultobj;
17139 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17140 bool result;
17141 PyObject * obj0 = 0 ;
17142 char *kwnames[] = {
17143 (char *) "self", NULL
17144 };
17145
17146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17148 if (SWIG_arg_fail(1)) SWIG_fail;
17149 result = (bool) ((arg1)->m_leftDown);
17150
17151 {
17152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17153 }
17154 return resultobj;
17155 fail:
17156 return NULL;
17157 }
17158
17159
17160 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17161 PyObject *resultobj;
17162 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17163 bool arg2 ;
17164 PyObject * obj0 = 0 ;
17165 PyObject * obj1 = 0 ;
17166 char *kwnames[] = {
17167 (char *) "self",(char *) "m_middleDown", NULL
17168 };
17169
17170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) 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 {
17174 arg2 = (bool)(SWIG_As_bool(obj1));
17175 if (SWIG_arg_fail(2)) SWIG_fail;
17176 }
17177 if (arg1) (arg1)->m_middleDown = arg2;
17178
17179 Py_INCREF(Py_None); resultobj = Py_None;
17180 return resultobj;
17181 fail:
17182 return NULL;
17183 }
17184
17185
17186 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17187 PyObject *resultobj;
17188 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17189 bool result;
17190 PyObject * obj0 = 0 ;
17191 char *kwnames[] = {
17192 (char *) "self", NULL
17193 };
17194
17195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17197 if (SWIG_arg_fail(1)) SWIG_fail;
17198 result = (bool) ((arg1)->m_middleDown);
17199
17200 {
17201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17202 }
17203 return resultobj;
17204 fail:
17205 return NULL;
17206 }
17207
17208
17209 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17210 PyObject *resultobj;
17211 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17212 bool arg2 ;
17213 PyObject * obj0 = 0 ;
17214 PyObject * obj1 = 0 ;
17215 char *kwnames[] = {
17216 (char *) "self",(char *) "m_rightDown", NULL
17217 };
17218
17219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) 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 {
17223 arg2 = (bool)(SWIG_As_bool(obj1));
17224 if (SWIG_arg_fail(2)) SWIG_fail;
17225 }
17226 if (arg1) (arg1)->m_rightDown = arg2;
17227
17228 Py_INCREF(Py_None); resultobj = Py_None;
17229 return resultobj;
17230 fail:
17231 return NULL;
17232 }
17233
17234
17235 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17236 PyObject *resultobj;
17237 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17238 bool result;
17239 PyObject * obj0 = 0 ;
17240 char *kwnames[] = {
17241 (char *) "self", NULL
17242 };
17243
17244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17246 if (SWIG_arg_fail(1)) SWIG_fail;
17247 result = (bool) ((arg1)->m_rightDown);
17248
17249 {
17250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17251 }
17252 return resultobj;
17253 fail:
17254 return NULL;
17255 }
17256
17257
17258 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17259 PyObject *resultobj;
17260 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17261 bool arg2 ;
17262 PyObject * obj0 = 0 ;
17263 PyObject * obj1 = 0 ;
17264 char *kwnames[] = {
17265 (char *) "self",(char *) "m_controlDown", NULL
17266 };
17267
17268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) 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 {
17272 arg2 = (bool)(SWIG_As_bool(obj1));
17273 if (SWIG_arg_fail(2)) SWIG_fail;
17274 }
17275 if (arg1) (arg1)->m_controlDown = arg2;
17276
17277 Py_INCREF(Py_None); resultobj = Py_None;
17278 return resultobj;
17279 fail:
17280 return NULL;
17281 }
17282
17283
17284 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17285 PyObject *resultobj;
17286 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17287 bool result;
17288 PyObject * obj0 = 0 ;
17289 char *kwnames[] = {
17290 (char *) "self", NULL
17291 };
17292
17293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17295 if (SWIG_arg_fail(1)) SWIG_fail;
17296 result = (bool) ((arg1)->m_controlDown);
17297
17298 {
17299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17300 }
17301 return resultobj;
17302 fail:
17303 return NULL;
17304 }
17305
17306
17307 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17308 PyObject *resultobj;
17309 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17310 bool arg2 ;
17311 PyObject * obj0 = 0 ;
17312 PyObject * obj1 = 0 ;
17313 char *kwnames[] = {
17314 (char *) "self",(char *) "m_shiftDown", NULL
17315 };
17316
17317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) 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 {
17321 arg2 = (bool)(SWIG_As_bool(obj1));
17322 if (SWIG_arg_fail(2)) SWIG_fail;
17323 }
17324 if (arg1) (arg1)->m_shiftDown = arg2;
17325
17326 Py_INCREF(Py_None); resultobj = Py_None;
17327 return resultobj;
17328 fail:
17329 return NULL;
17330 }
17331
17332
17333 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17334 PyObject *resultobj;
17335 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17336 bool result;
17337 PyObject * obj0 = 0 ;
17338 char *kwnames[] = {
17339 (char *) "self", NULL
17340 };
17341
17342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17344 if (SWIG_arg_fail(1)) SWIG_fail;
17345 result = (bool) ((arg1)->m_shiftDown);
17346
17347 {
17348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17349 }
17350 return resultobj;
17351 fail:
17352 return NULL;
17353 }
17354
17355
17356 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17357 PyObject *resultobj;
17358 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17359 bool arg2 ;
17360 PyObject * obj0 = 0 ;
17361 PyObject * obj1 = 0 ;
17362 char *kwnames[] = {
17363 (char *) "self",(char *) "m_altDown", NULL
17364 };
17365
17366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) 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 {
17370 arg2 = (bool)(SWIG_As_bool(obj1));
17371 if (SWIG_arg_fail(2)) SWIG_fail;
17372 }
17373 if (arg1) (arg1)->m_altDown = arg2;
17374
17375 Py_INCREF(Py_None); resultobj = Py_None;
17376 return resultobj;
17377 fail:
17378 return NULL;
17379 }
17380
17381
17382 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17383 PyObject *resultobj;
17384 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17385 bool result;
17386 PyObject * obj0 = 0 ;
17387 char *kwnames[] = {
17388 (char *) "self", NULL
17389 };
17390
17391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17393 if (SWIG_arg_fail(1)) SWIG_fail;
17394 result = (bool) ((arg1)->m_altDown);
17395
17396 {
17397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17398 }
17399 return resultobj;
17400 fail:
17401 return NULL;
17402 }
17403
17404
17405 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17406 PyObject *resultobj;
17407 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17408 bool arg2 ;
17409 PyObject * obj0 = 0 ;
17410 PyObject * obj1 = 0 ;
17411 char *kwnames[] = {
17412 (char *) "self",(char *) "m_metaDown", NULL
17413 };
17414
17415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) 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 {
17419 arg2 = (bool)(SWIG_As_bool(obj1));
17420 if (SWIG_arg_fail(2)) SWIG_fail;
17421 }
17422 if (arg1) (arg1)->m_metaDown = arg2;
17423
17424 Py_INCREF(Py_None); resultobj = Py_None;
17425 return resultobj;
17426 fail:
17427 return NULL;
17428 }
17429
17430
17431 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17432 PyObject *resultobj;
17433 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17434 bool result;
17435 PyObject * obj0 = 0 ;
17436 char *kwnames[] = {
17437 (char *) "self", NULL
17438 };
17439
17440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17442 if (SWIG_arg_fail(1)) SWIG_fail;
17443 result = (bool) ((arg1)->m_metaDown);
17444
17445 {
17446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17447 }
17448 return resultobj;
17449 fail:
17450 return NULL;
17451 }
17452
17453
17454 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17455 PyObject *resultobj;
17456 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17457 int arg2 ;
17458 PyObject * obj0 = 0 ;
17459 PyObject * obj1 = 0 ;
17460 char *kwnames[] = {
17461 (char *) "self",(char *) "m_wheelRotation", NULL
17462 };
17463
17464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17466 if (SWIG_arg_fail(1)) SWIG_fail;
17467 {
17468 arg2 = (int)(SWIG_As_int(obj1));
17469 if (SWIG_arg_fail(2)) SWIG_fail;
17470 }
17471 if (arg1) (arg1)->m_wheelRotation = arg2;
17472
17473 Py_INCREF(Py_None); resultobj = Py_None;
17474 return resultobj;
17475 fail:
17476 return NULL;
17477 }
17478
17479
17480 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17481 PyObject *resultobj;
17482 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17483 int result;
17484 PyObject * obj0 = 0 ;
17485 char *kwnames[] = {
17486 (char *) "self", NULL
17487 };
17488
17489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17491 if (SWIG_arg_fail(1)) SWIG_fail;
17492 result = (int) ((arg1)->m_wheelRotation);
17493
17494 {
17495 resultobj = SWIG_From_int((int)(result));
17496 }
17497 return resultobj;
17498 fail:
17499 return NULL;
17500 }
17501
17502
17503 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17504 PyObject *resultobj;
17505 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17506 int arg2 ;
17507 PyObject * obj0 = 0 ;
17508 PyObject * obj1 = 0 ;
17509 char *kwnames[] = {
17510 (char *) "self",(char *) "m_wheelDelta", NULL
17511 };
17512
17513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17515 if (SWIG_arg_fail(1)) SWIG_fail;
17516 {
17517 arg2 = (int)(SWIG_As_int(obj1));
17518 if (SWIG_arg_fail(2)) SWIG_fail;
17519 }
17520 if (arg1) (arg1)->m_wheelDelta = arg2;
17521
17522 Py_INCREF(Py_None); resultobj = Py_None;
17523 return resultobj;
17524 fail:
17525 return NULL;
17526 }
17527
17528
17529 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17530 PyObject *resultobj;
17531 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17532 int result;
17533 PyObject * obj0 = 0 ;
17534 char *kwnames[] = {
17535 (char *) "self", NULL
17536 };
17537
17538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17540 if (SWIG_arg_fail(1)) SWIG_fail;
17541 result = (int) ((arg1)->m_wheelDelta);
17542
17543 {
17544 resultobj = SWIG_From_int((int)(result));
17545 }
17546 return resultobj;
17547 fail:
17548 return NULL;
17549 }
17550
17551
17552 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17553 PyObject *resultobj;
17554 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17555 int arg2 ;
17556 PyObject * obj0 = 0 ;
17557 PyObject * obj1 = 0 ;
17558 char *kwnames[] = {
17559 (char *) "self",(char *) "m_linesPerAction", NULL
17560 };
17561
17562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17564 if (SWIG_arg_fail(1)) SWIG_fail;
17565 {
17566 arg2 = (int)(SWIG_As_int(obj1));
17567 if (SWIG_arg_fail(2)) SWIG_fail;
17568 }
17569 if (arg1) (arg1)->m_linesPerAction = arg2;
17570
17571 Py_INCREF(Py_None); resultobj = Py_None;
17572 return resultobj;
17573 fail:
17574 return NULL;
17575 }
17576
17577
17578 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17579 PyObject *resultobj;
17580 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17581 int result;
17582 PyObject * obj0 = 0 ;
17583 char *kwnames[] = {
17584 (char *) "self", NULL
17585 };
17586
17587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17589 if (SWIG_arg_fail(1)) SWIG_fail;
17590 result = (int) ((arg1)->m_linesPerAction);
17591
17592 {
17593 resultobj = SWIG_From_int((int)(result));
17594 }
17595 return resultobj;
17596 fail:
17597 return NULL;
17598 }
17599
17600
17601 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17602 PyObject *obj;
17603 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17604 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17605 Py_INCREF(obj);
17606 return Py_BuildValue((char *)"");
17607 }
17608 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17609 PyObject *resultobj;
17610 int arg1 = (int) 0 ;
17611 int arg2 = (int) 0 ;
17612 wxSetCursorEvent *result;
17613 PyObject * obj0 = 0 ;
17614 PyObject * obj1 = 0 ;
17615 char *kwnames[] = {
17616 (char *) "x",(char *) "y", NULL
17617 };
17618
17619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17620 if (obj0) {
17621 {
17622 arg1 = (int)(SWIG_As_int(obj0));
17623 if (SWIG_arg_fail(1)) SWIG_fail;
17624 }
17625 }
17626 if (obj1) {
17627 {
17628 arg2 = (int)(SWIG_As_int(obj1));
17629 if (SWIG_arg_fail(2)) SWIG_fail;
17630 }
17631 }
17632 {
17633 PyThreadState* __tstate = wxPyBeginAllowThreads();
17634 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17635
17636 wxPyEndAllowThreads(__tstate);
17637 if (PyErr_Occurred()) SWIG_fail;
17638 }
17639 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17640 return resultobj;
17641 fail:
17642 return NULL;
17643 }
17644
17645
17646 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17647 PyObject *resultobj;
17648 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17649 int result;
17650 PyObject * obj0 = 0 ;
17651 char *kwnames[] = {
17652 (char *) "self", NULL
17653 };
17654
17655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17657 if (SWIG_arg_fail(1)) SWIG_fail;
17658 {
17659 PyThreadState* __tstate = wxPyBeginAllowThreads();
17660 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17661
17662 wxPyEndAllowThreads(__tstate);
17663 if (PyErr_Occurred()) SWIG_fail;
17664 }
17665 {
17666 resultobj = SWIG_From_int((int)(result));
17667 }
17668 return resultobj;
17669 fail:
17670 return NULL;
17671 }
17672
17673
17674 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17675 PyObject *resultobj;
17676 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17677 int result;
17678 PyObject * obj0 = 0 ;
17679 char *kwnames[] = {
17680 (char *) "self", NULL
17681 };
17682
17683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17685 if (SWIG_arg_fail(1)) SWIG_fail;
17686 {
17687 PyThreadState* __tstate = wxPyBeginAllowThreads();
17688 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17689
17690 wxPyEndAllowThreads(__tstate);
17691 if (PyErr_Occurred()) SWIG_fail;
17692 }
17693 {
17694 resultobj = SWIG_From_int((int)(result));
17695 }
17696 return resultobj;
17697 fail:
17698 return NULL;
17699 }
17700
17701
17702 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17703 PyObject *resultobj;
17704 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17705 wxCursor *arg2 = 0 ;
17706 PyObject * obj0 = 0 ;
17707 PyObject * obj1 = 0 ;
17708 char *kwnames[] = {
17709 (char *) "self",(char *) "cursor", NULL
17710 };
17711
17712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
17713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17714 if (SWIG_arg_fail(1)) SWIG_fail;
17715 {
17716 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
17717 if (SWIG_arg_fail(2)) SWIG_fail;
17718 if (arg2 == NULL) {
17719 SWIG_null_ref("wxCursor");
17720 }
17721 if (SWIG_arg_fail(2)) SWIG_fail;
17722 }
17723 {
17724 PyThreadState* __tstate = wxPyBeginAllowThreads();
17725 (arg1)->SetCursor((wxCursor const &)*arg2);
17726
17727 wxPyEndAllowThreads(__tstate);
17728 if (PyErr_Occurred()) SWIG_fail;
17729 }
17730 Py_INCREF(Py_None); resultobj = Py_None;
17731 return resultobj;
17732 fail:
17733 return NULL;
17734 }
17735
17736
17737 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17738 PyObject *resultobj;
17739 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17740 wxCursor *result;
17741 PyObject * obj0 = 0 ;
17742 char *kwnames[] = {
17743 (char *) "self", NULL
17744 };
17745
17746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
17747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17748 if (SWIG_arg_fail(1)) SWIG_fail;
17749 {
17750 PyThreadState* __tstate = wxPyBeginAllowThreads();
17751 {
17752 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
17753 result = (wxCursor *) &_result_ref;
17754 }
17755
17756 wxPyEndAllowThreads(__tstate);
17757 if (PyErr_Occurred()) SWIG_fail;
17758 }
17759 {
17760 wxCursor* resultptr = new wxCursor(*result);
17761 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
17762 }
17763 return resultobj;
17764 fail:
17765 return NULL;
17766 }
17767
17768
17769 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17770 PyObject *resultobj;
17771 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17772 bool result;
17773 PyObject * obj0 = 0 ;
17774 char *kwnames[] = {
17775 (char *) "self", NULL
17776 };
17777
17778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
17779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17780 if (SWIG_arg_fail(1)) SWIG_fail;
17781 {
17782 PyThreadState* __tstate = wxPyBeginAllowThreads();
17783 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
17784
17785 wxPyEndAllowThreads(__tstate);
17786 if (PyErr_Occurred()) SWIG_fail;
17787 }
17788 {
17789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17790 }
17791 return resultobj;
17792 fail:
17793 return NULL;
17794 }
17795
17796
17797 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
17798 PyObject *obj;
17799 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17800 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
17801 Py_INCREF(obj);
17802 return Py_BuildValue((char *)"");
17803 }
17804 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17805 PyObject *resultobj;
17806 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17807 wxKeyEvent *result;
17808 PyObject * obj0 = 0 ;
17809 char *kwnames[] = {
17810 (char *) "keyType", NULL
17811 };
17812
17813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
17814 if (obj0) {
17815 {
17816 arg1 = (wxEventType)(SWIG_As_int(obj0));
17817 if (SWIG_arg_fail(1)) SWIG_fail;
17818 }
17819 }
17820 {
17821 PyThreadState* __tstate = wxPyBeginAllowThreads();
17822 result = (wxKeyEvent *)new wxKeyEvent(arg1);
17823
17824 wxPyEndAllowThreads(__tstate);
17825 if (PyErr_Occurred()) SWIG_fail;
17826 }
17827 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
17828 return resultobj;
17829 fail:
17830 return NULL;
17831 }
17832
17833
17834 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17835 PyObject *resultobj;
17836 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17837 bool result;
17838 PyObject * obj0 = 0 ;
17839 char *kwnames[] = {
17840 (char *) "self", NULL
17841 };
17842
17843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
17844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17845 if (SWIG_arg_fail(1)) SWIG_fail;
17846 {
17847 PyThreadState* __tstate = wxPyBeginAllowThreads();
17848 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
17849
17850 wxPyEndAllowThreads(__tstate);
17851 if (PyErr_Occurred()) SWIG_fail;
17852 }
17853 {
17854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17855 }
17856 return resultobj;
17857 fail:
17858 return NULL;
17859 }
17860
17861
17862 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17863 PyObject *resultobj;
17864 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17865 bool result;
17866 PyObject * obj0 = 0 ;
17867 char *kwnames[] = {
17868 (char *) "self", NULL
17869 };
17870
17871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
17872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17873 if (SWIG_arg_fail(1)) SWIG_fail;
17874 {
17875 PyThreadState* __tstate = wxPyBeginAllowThreads();
17876 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
17877
17878 wxPyEndAllowThreads(__tstate);
17879 if (PyErr_Occurred()) SWIG_fail;
17880 }
17881 {
17882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17883 }
17884 return resultobj;
17885 fail:
17886 return NULL;
17887 }
17888
17889
17890 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17891 PyObject *resultobj;
17892 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17893 bool result;
17894 PyObject * obj0 = 0 ;
17895 char *kwnames[] = {
17896 (char *) "self", NULL
17897 };
17898
17899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
17900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17901 if (SWIG_arg_fail(1)) SWIG_fail;
17902 {
17903 PyThreadState* __tstate = wxPyBeginAllowThreads();
17904 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
17905
17906 wxPyEndAllowThreads(__tstate);
17907 if (PyErr_Occurred()) SWIG_fail;
17908 }
17909 {
17910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17911 }
17912 return resultobj;
17913 fail:
17914 return NULL;
17915 }
17916
17917
17918 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17919 PyObject *resultobj;
17920 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17921 bool result;
17922 PyObject * obj0 = 0 ;
17923 char *kwnames[] = {
17924 (char *) "self", NULL
17925 };
17926
17927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
17928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17929 if (SWIG_arg_fail(1)) SWIG_fail;
17930 {
17931 PyThreadState* __tstate = wxPyBeginAllowThreads();
17932 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
17933
17934 wxPyEndAllowThreads(__tstate);
17935 if (PyErr_Occurred()) SWIG_fail;
17936 }
17937 {
17938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17939 }
17940 return resultobj;
17941 fail:
17942 return NULL;
17943 }
17944
17945
17946 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17947 PyObject *resultobj;
17948 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17949 bool result;
17950 PyObject * obj0 = 0 ;
17951 char *kwnames[] = {
17952 (char *) "self", NULL
17953 };
17954
17955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
17956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17957 if (SWIG_arg_fail(1)) SWIG_fail;
17958 {
17959 PyThreadState* __tstate = wxPyBeginAllowThreads();
17960 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
17961
17962 wxPyEndAllowThreads(__tstate);
17963 if (PyErr_Occurred()) SWIG_fail;
17964 }
17965 {
17966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17967 }
17968 return resultobj;
17969 fail:
17970 return NULL;
17971 }
17972
17973
17974 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
17975 PyObject *resultobj;
17976 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17977 bool result;
17978 PyObject * obj0 = 0 ;
17979 char *kwnames[] = {
17980 (char *) "self", NULL
17981 };
17982
17983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
17984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17985 if (SWIG_arg_fail(1)) SWIG_fail;
17986 {
17987 PyThreadState* __tstate = wxPyBeginAllowThreads();
17988 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
17989
17990 wxPyEndAllowThreads(__tstate);
17991 if (PyErr_Occurred()) SWIG_fail;
17992 }
17993 {
17994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17995 }
17996 return resultobj;
17997 fail:
17998 return NULL;
17999 }
18000
18001
18002 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18003 PyObject *resultobj;
18004 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18005 int result;
18006 PyObject * obj0 = 0 ;
18007 char *kwnames[] = {
18008 (char *) "self", NULL
18009 };
18010
18011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18013 if (SWIG_arg_fail(1)) SWIG_fail;
18014 {
18015 PyThreadState* __tstate = wxPyBeginAllowThreads();
18016 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18017
18018 wxPyEndAllowThreads(__tstate);
18019 if (PyErr_Occurred()) SWIG_fail;
18020 }
18021 {
18022 resultobj = SWIG_From_int((int)(result));
18023 }
18024 return resultobj;
18025 fail:
18026 return NULL;
18027 }
18028
18029
18030 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18031 PyObject *resultobj;
18032 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18033 int result;
18034 PyObject * obj0 = 0 ;
18035 char *kwnames[] = {
18036 (char *) "self", NULL
18037 };
18038
18039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18041 if (SWIG_arg_fail(1)) SWIG_fail;
18042 {
18043 PyThreadState* __tstate = wxPyBeginAllowThreads();
18044 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18045
18046 wxPyEndAllowThreads(__tstate);
18047 if (PyErr_Occurred()) SWIG_fail;
18048 }
18049 {
18050 resultobj = SWIG_From_int((int)(result));
18051 }
18052 return resultobj;
18053 fail:
18054 return NULL;
18055 }
18056
18057
18058 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18059 PyObject *resultobj;
18060 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18061 unsigned int result;
18062 PyObject * obj0 = 0 ;
18063 char *kwnames[] = {
18064 (char *) "self", NULL
18065 };
18066
18067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18069 if (SWIG_arg_fail(1)) SWIG_fail;
18070 {
18071 PyThreadState* __tstate = wxPyBeginAllowThreads();
18072 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18073
18074 wxPyEndAllowThreads(__tstate);
18075 if (PyErr_Occurred()) SWIG_fail;
18076 }
18077 {
18078 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18079 }
18080 return resultobj;
18081 fail:
18082 return NULL;
18083 }
18084
18085
18086 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18087 PyObject *resultobj;
18088 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18089 unsigned int result;
18090 PyObject * obj0 = 0 ;
18091 char *kwnames[] = {
18092 (char *) "self", NULL
18093 };
18094
18095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18097 if (SWIG_arg_fail(1)) SWIG_fail;
18098 {
18099 PyThreadState* __tstate = wxPyBeginAllowThreads();
18100 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18101
18102 wxPyEndAllowThreads(__tstate);
18103 if (PyErr_Occurred()) SWIG_fail;
18104 }
18105 {
18106 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18107 }
18108 return resultobj;
18109 fail:
18110 return NULL;
18111 }
18112
18113
18114 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18115 PyObject *resultobj;
18116 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18117 wxPoint result;
18118 PyObject * obj0 = 0 ;
18119 char *kwnames[] = {
18120 (char *) "self", NULL
18121 };
18122
18123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18125 if (SWIG_arg_fail(1)) SWIG_fail;
18126 {
18127 PyThreadState* __tstate = wxPyBeginAllowThreads();
18128 result = (arg1)->GetPosition();
18129
18130 wxPyEndAllowThreads(__tstate);
18131 if (PyErr_Occurred()) SWIG_fail;
18132 }
18133 {
18134 wxPoint * resultptr;
18135 resultptr = new wxPoint((wxPoint &)(result));
18136 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18137 }
18138 return resultobj;
18139 fail:
18140 return NULL;
18141 }
18142
18143
18144 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18145 PyObject *resultobj;
18146 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18147 long *arg2 = (long *) 0 ;
18148 long *arg3 = (long *) 0 ;
18149 long temp2 ;
18150 int res2 = 0 ;
18151 long temp3 ;
18152 int res3 = 0 ;
18153 PyObject * obj0 = 0 ;
18154 char *kwnames[] = {
18155 (char *) "self", NULL
18156 };
18157
18158 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18159 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18162 if (SWIG_arg_fail(1)) SWIG_fail;
18163 {
18164 PyThreadState* __tstate = wxPyBeginAllowThreads();
18165 (arg1)->GetPosition(arg2,arg3);
18166
18167 wxPyEndAllowThreads(__tstate);
18168 if (PyErr_Occurred()) SWIG_fail;
18169 }
18170 Py_INCREF(Py_None); resultobj = Py_None;
18171 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18172 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18173 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18174 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18175 return resultobj;
18176 fail:
18177 return NULL;
18178 }
18179
18180
18181 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18182 PyObject *resultobj;
18183 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18184 int result;
18185 PyObject * obj0 = 0 ;
18186 char *kwnames[] = {
18187 (char *) "self", NULL
18188 };
18189
18190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18192 if (SWIG_arg_fail(1)) SWIG_fail;
18193 {
18194 PyThreadState* __tstate = wxPyBeginAllowThreads();
18195 result = (int)((wxKeyEvent const *)arg1)->GetX();
18196
18197 wxPyEndAllowThreads(__tstate);
18198 if (PyErr_Occurred()) SWIG_fail;
18199 }
18200 {
18201 resultobj = SWIG_From_int((int)(result));
18202 }
18203 return resultobj;
18204 fail:
18205 return NULL;
18206 }
18207
18208
18209 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18210 PyObject *resultobj;
18211 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18212 int result;
18213 PyObject * obj0 = 0 ;
18214 char *kwnames[] = {
18215 (char *) "self", NULL
18216 };
18217
18218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18220 if (SWIG_arg_fail(1)) SWIG_fail;
18221 {
18222 PyThreadState* __tstate = wxPyBeginAllowThreads();
18223 result = (int)((wxKeyEvent const *)arg1)->GetY();
18224
18225 wxPyEndAllowThreads(__tstate);
18226 if (PyErr_Occurred()) SWIG_fail;
18227 }
18228 {
18229 resultobj = SWIG_From_int((int)(result));
18230 }
18231 return resultobj;
18232 fail:
18233 return NULL;
18234 }
18235
18236
18237 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18238 PyObject *resultobj;
18239 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18240 int arg2 ;
18241 PyObject * obj0 = 0 ;
18242 PyObject * obj1 = 0 ;
18243 char *kwnames[] = {
18244 (char *) "self",(char *) "m_x", NULL
18245 };
18246
18247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) 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 {
18251 arg2 = (int)(SWIG_As_int(obj1));
18252 if (SWIG_arg_fail(2)) SWIG_fail;
18253 }
18254 if (arg1) (arg1)->m_x = arg2;
18255
18256 Py_INCREF(Py_None); resultobj = Py_None;
18257 return resultobj;
18258 fail:
18259 return NULL;
18260 }
18261
18262
18263 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18264 PyObject *resultobj;
18265 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18266 int result;
18267 PyObject * obj0 = 0 ;
18268 char *kwnames[] = {
18269 (char *) "self", NULL
18270 };
18271
18272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18274 if (SWIG_arg_fail(1)) SWIG_fail;
18275 result = (int) ((arg1)->m_x);
18276
18277 {
18278 resultobj = SWIG_From_int((int)(result));
18279 }
18280 return resultobj;
18281 fail:
18282 return NULL;
18283 }
18284
18285
18286 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18287 PyObject *resultobj;
18288 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18289 int arg2 ;
18290 PyObject * obj0 = 0 ;
18291 PyObject * obj1 = 0 ;
18292 char *kwnames[] = {
18293 (char *) "self",(char *) "m_y", NULL
18294 };
18295
18296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) 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 {
18300 arg2 = (int)(SWIG_As_int(obj1));
18301 if (SWIG_arg_fail(2)) SWIG_fail;
18302 }
18303 if (arg1) (arg1)->m_y = arg2;
18304
18305 Py_INCREF(Py_None); resultobj = Py_None;
18306 return resultobj;
18307 fail:
18308 return NULL;
18309 }
18310
18311
18312 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18313 PyObject *resultobj;
18314 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18315 int result;
18316 PyObject * obj0 = 0 ;
18317 char *kwnames[] = {
18318 (char *) "self", NULL
18319 };
18320
18321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18323 if (SWIG_arg_fail(1)) SWIG_fail;
18324 result = (int) ((arg1)->m_y);
18325
18326 {
18327 resultobj = SWIG_From_int((int)(result));
18328 }
18329 return resultobj;
18330 fail:
18331 return NULL;
18332 }
18333
18334
18335 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18336 PyObject *resultobj;
18337 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18338 long arg2 ;
18339 PyObject * obj0 = 0 ;
18340 PyObject * obj1 = 0 ;
18341 char *kwnames[] = {
18342 (char *) "self",(char *) "m_keyCode", NULL
18343 };
18344
18345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) 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 {
18349 arg2 = (long)(SWIG_As_long(obj1));
18350 if (SWIG_arg_fail(2)) SWIG_fail;
18351 }
18352 if (arg1) (arg1)->m_keyCode = arg2;
18353
18354 Py_INCREF(Py_None); resultobj = Py_None;
18355 return resultobj;
18356 fail:
18357 return NULL;
18358 }
18359
18360
18361 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18362 PyObject *resultobj;
18363 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18364 long result;
18365 PyObject * obj0 = 0 ;
18366 char *kwnames[] = {
18367 (char *) "self", NULL
18368 };
18369
18370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18372 if (SWIG_arg_fail(1)) SWIG_fail;
18373 result = (long) ((arg1)->m_keyCode);
18374
18375 {
18376 resultobj = SWIG_From_long((long)(result));
18377 }
18378 return resultobj;
18379 fail:
18380 return NULL;
18381 }
18382
18383
18384 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18385 PyObject *resultobj;
18386 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18387 bool arg2 ;
18388 PyObject * obj0 = 0 ;
18389 PyObject * obj1 = 0 ;
18390 char *kwnames[] = {
18391 (char *) "self",(char *) "m_controlDown", NULL
18392 };
18393
18394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) 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 {
18398 arg2 = (bool)(SWIG_As_bool(obj1));
18399 if (SWIG_arg_fail(2)) SWIG_fail;
18400 }
18401 if (arg1) (arg1)->m_controlDown = arg2;
18402
18403 Py_INCREF(Py_None); resultobj = Py_None;
18404 return resultobj;
18405 fail:
18406 return NULL;
18407 }
18408
18409
18410 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18411 PyObject *resultobj;
18412 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18413 bool result;
18414 PyObject * obj0 = 0 ;
18415 char *kwnames[] = {
18416 (char *) "self", NULL
18417 };
18418
18419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18421 if (SWIG_arg_fail(1)) SWIG_fail;
18422 result = (bool) ((arg1)->m_controlDown);
18423
18424 {
18425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18426 }
18427 return resultobj;
18428 fail:
18429 return NULL;
18430 }
18431
18432
18433 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18434 PyObject *resultobj;
18435 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18436 bool arg2 ;
18437 PyObject * obj0 = 0 ;
18438 PyObject * obj1 = 0 ;
18439 char *kwnames[] = {
18440 (char *) "self",(char *) "m_shiftDown", NULL
18441 };
18442
18443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) 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 {
18447 arg2 = (bool)(SWIG_As_bool(obj1));
18448 if (SWIG_arg_fail(2)) SWIG_fail;
18449 }
18450 if (arg1) (arg1)->m_shiftDown = arg2;
18451
18452 Py_INCREF(Py_None); resultobj = Py_None;
18453 return resultobj;
18454 fail:
18455 return NULL;
18456 }
18457
18458
18459 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18460 PyObject *resultobj;
18461 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18462 bool result;
18463 PyObject * obj0 = 0 ;
18464 char *kwnames[] = {
18465 (char *) "self", NULL
18466 };
18467
18468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18470 if (SWIG_arg_fail(1)) SWIG_fail;
18471 result = (bool) ((arg1)->m_shiftDown);
18472
18473 {
18474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18475 }
18476 return resultobj;
18477 fail:
18478 return NULL;
18479 }
18480
18481
18482 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18483 PyObject *resultobj;
18484 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18485 bool arg2 ;
18486 PyObject * obj0 = 0 ;
18487 PyObject * obj1 = 0 ;
18488 char *kwnames[] = {
18489 (char *) "self",(char *) "m_altDown", NULL
18490 };
18491
18492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) 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 {
18496 arg2 = (bool)(SWIG_As_bool(obj1));
18497 if (SWIG_arg_fail(2)) SWIG_fail;
18498 }
18499 if (arg1) (arg1)->m_altDown = arg2;
18500
18501 Py_INCREF(Py_None); resultobj = Py_None;
18502 return resultobj;
18503 fail:
18504 return NULL;
18505 }
18506
18507
18508 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18509 PyObject *resultobj;
18510 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18511 bool result;
18512 PyObject * obj0 = 0 ;
18513 char *kwnames[] = {
18514 (char *) "self", NULL
18515 };
18516
18517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18519 if (SWIG_arg_fail(1)) SWIG_fail;
18520 result = (bool) ((arg1)->m_altDown);
18521
18522 {
18523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18524 }
18525 return resultobj;
18526 fail:
18527 return NULL;
18528 }
18529
18530
18531 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18532 PyObject *resultobj;
18533 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18534 bool arg2 ;
18535 PyObject * obj0 = 0 ;
18536 PyObject * obj1 = 0 ;
18537 char *kwnames[] = {
18538 (char *) "self",(char *) "m_metaDown", NULL
18539 };
18540
18541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) 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 {
18545 arg2 = (bool)(SWIG_As_bool(obj1));
18546 if (SWIG_arg_fail(2)) SWIG_fail;
18547 }
18548 if (arg1) (arg1)->m_metaDown = arg2;
18549
18550 Py_INCREF(Py_None); resultobj = Py_None;
18551 return resultobj;
18552 fail:
18553 return NULL;
18554 }
18555
18556
18557 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18558 PyObject *resultobj;
18559 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18560 bool result;
18561 PyObject * obj0 = 0 ;
18562 char *kwnames[] = {
18563 (char *) "self", NULL
18564 };
18565
18566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18568 if (SWIG_arg_fail(1)) SWIG_fail;
18569 result = (bool) ((arg1)->m_metaDown);
18570
18571 {
18572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18573 }
18574 return resultobj;
18575 fail:
18576 return NULL;
18577 }
18578
18579
18580 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18581 PyObject *resultobj;
18582 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18583 bool arg2 ;
18584 PyObject * obj0 = 0 ;
18585 PyObject * obj1 = 0 ;
18586 char *kwnames[] = {
18587 (char *) "self",(char *) "m_scanCode", NULL
18588 };
18589
18590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18592 if (SWIG_arg_fail(1)) SWIG_fail;
18593 {
18594 arg2 = (bool)(SWIG_As_bool(obj1));
18595 if (SWIG_arg_fail(2)) SWIG_fail;
18596 }
18597 if (arg1) (arg1)->m_scanCode = arg2;
18598
18599 Py_INCREF(Py_None); resultobj = Py_None;
18600 return resultobj;
18601 fail:
18602 return NULL;
18603 }
18604
18605
18606 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18607 PyObject *resultobj;
18608 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18609 bool result;
18610 PyObject * obj0 = 0 ;
18611 char *kwnames[] = {
18612 (char *) "self", NULL
18613 };
18614
18615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18617 if (SWIG_arg_fail(1)) SWIG_fail;
18618 result = (bool) ((arg1)->m_scanCode);
18619
18620 {
18621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18622 }
18623 return resultobj;
18624 fail:
18625 return NULL;
18626 }
18627
18628
18629 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18630 PyObject *resultobj;
18631 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18632 unsigned int arg2 ;
18633 PyObject * obj0 = 0 ;
18634 PyObject * obj1 = 0 ;
18635 char *kwnames[] = {
18636 (char *) "self",(char *) "m_rawCode", NULL
18637 };
18638
18639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18641 if (SWIG_arg_fail(1)) SWIG_fail;
18642 {
18643 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18644 if (SWIG_arg_fail(2)) SWIG_fail;
18645 }
18646 if (arg1) (arg1)->m_rawCode = arg2;
18647
18648 Py_INCREF(Py_None); resultobj = Py_None;
18649 return resultobj;
18650 fail:
18651 return NULL;
18652 }
18653
18654
18655 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18656 PyObject *resultobj;
18657 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18658 unsigned int result;
18659 PyObject * obj0 = 0 ;
18660 char *kwnames[] = {
18661 (char *) "self", NULL
18662 };
18663
18664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18666 if (SWIG_arg_fail(1)) SWIG_fail;
18667 result = (unsigned int) ((arg1)->m_rawCode);
18668
18669 {
18670 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18671 }
18672 return resultobj;
18673 fail:
18674 return NULL;
18675 }
18676
18677
18678 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18679 PyObject *resultobj;
18680 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18681 unsigned int arg2 ;
18682 PyObject * obj0 = 0 ;
18683 PyObject * obj1 = 0 ;
18684 char *kwnames[] = {
18685 (char *) "self",(char *) "m_rawFlags", NULL
18686 };
18687
18688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18690 if (SWIG_arg_fail(1)) SWIG_fail;
18691 {
18692 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18693 if (SWIG_arg_fail(2)) SWIG_fail;
18694 }
18695 if (arg1) (arg1)->m_rawFlags = arg2;
18696
18697 Py_INCREF(Py_None); resultobj = Py_None;
18698 return resultobj;
18699 fail:
18700 return NULL;
18701 }
18702
18703
18704 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
18705 PyObject *resultobj;
18706 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18707 unsigned int result;
18708 PyObject * obj0 = 0 ;
18709 char *kwnames[] = {
18710 (char *) "self", NULL
18711 };
18712
18713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
18714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18715 if (SWIG_arg_fail(1)) SWIG_fail;
18716 result = (unsigned int) ((arg1)->m_rawFlags);
18717
18718 {
18719 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18720 }
18721 return resultobj;
18722 fail:
18723 return NULL;
18724 }
18725
18726
18727 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
18728 PyObject *obj;
18729 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18730 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
18731 Py_INCREF(obj);
18732 return Py_BuildValue((char *)"");
18733 }
18734 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18735 PyObject *resultobj;
18736 wxSize const &arg1_defvalue = wxDefaultSize ;
18737 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
18738 int arg2 = (int) 0 ;
18739 wxSizeEvent *result;
18740 wxSize temp1 ;
18741 PyObject * obj0 = 0 ;
18742 PyObject * obj1 = 0 ;
18743 char *kwnames[] = {
18744 (char *) "sz",(char *) "winid", NULL
18745 };
18746
18747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
18748 if (obj0) {
18749 {
18750 arg1 = &temp1;
18751 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
18752 }
18753 }
18754 if (obj1) {
18755 {
18756 arg2 = (int)(SWIG_As_int(obj1));
18757 if (SWIG_arg_fail(2)) SWIG_fail;
18758 }
18759 }
18760 {
18761 PyThreadState* __tstate = wxPyBeginAllowThreads();
18762 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
18763
18764 wxPyEndAllowThreads(__tstate);
18765 if (PyErr_Occurred()) SWIG_fail;
18766 }
18767 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
18768 return resultobj;
18769 fail:
18770 return NULL;
18771 }
18772
18773
18774 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18775 PyObject *resultobj;
18776 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18777 wxSize result;
18778 PyObject * obj0 = 0 ;
18779 char *kwnames[] = {
18780 (char *) "self", NULL
18781 };
18782
18783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
18784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18785 if (SWIG_arg_fail(1)) SWIG_fail;
18786 {
18787 PyThreadState* __tstate = wxPyBeginAllowThreads();
18788 result = ((wxSizeEvent const *)arg1)->GetSize();
18789
18790 wxPyEndAllowThreads(__tstate);
18791 if (PyErr_Occurred()) SWIG_fail;
18792 }
18793 {
18794 wxSize * resultptr;
18795 resultptr = new wxSize((wxSize &)(result));
18796 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18797 }
18798 return resultobj;
18799 fail:
18800 return NULL;
18801 }
18802
18803
18804 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18805 PyObject *resultobj;
18806 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18807 wxRect result;
18808 PyObject * obj0 = 0 ;
18809 char *kwnames[] = {
18810 (char *) "self", NULL
18811 };
18812
18813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
18814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18815 if (SWIG_arg_fail(1)) SWIG_fail;
18816 {
18817 PyThreadState* __tstate = wxPyBeginAllowThreads();
18818 result = ((wxSizeEvent const *)arg1)->GetRect();
18819
18820 wxPyEndAllowThreads(__tstate);
18821 if (PyErr_Occurred()) SWIG_fail;
18822 }
18823 {
18824 wxRect * resultptr;
18825 resultptr = new wxRect((wxRect &)(result));
18826 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18827 }
18828 return resultobj;
18829 fail:
18830 return NULL;
18831 }
18832
18833
18834 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18835 PyObject *resultobj;
18836 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18837 wxRect arg2 ;
18838 PyObject * obj0 = 0 ;
18839 PyObject * obj1 = 0 ;
18840 char *kwnames[] = {
18841 (char *) "self",(char *) "rect", NULL
18842 };
18843
18844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18846 if (SWIG_arg_fail(1)) SWIG_fail;
18847 {
18848 wxRect * argp;
18849 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18850 if (SWIG_arg_fail(2)) SWIG_fail;
18851 if (argp == NULL) {
18852 SWIG_null_ref("wxRect");
18853 }
18854 if (SWIG_arg_fail(2)) SWIG_fail;
18855 arg2 = *argp;
18856 }
18857 {
18858 PyThreadState* __tstate = wxPyBeginAllowThreads();
18859 (arg1)->SetRect(arg2);
18860
18861 wxPyEndAllowThreads(__tstate);
18862 if (PyErr_Occurred()) SWIG_fail;
18863 }
18864 Py_INCREF(Py_None); resultobj = Py_None;
18865 return resultobj;
18866 fail:
18867 return NULL;
18868 }
18869
18870
18871 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18872 PyObject *resultobj;
18873 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18874 wxSize arg2 ;
18875 PyObject * obj0 = 0 ;
18876 PyObject * obj1 = 0 ;
18877 char *kwnames[] = {
18878 (char *) "self",(char *) "size", NULL
18879 };
18880
18881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
18882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18883 if (SWIG_arg_fail(1)) SWIG_fail;
18884 {
18885 wxSize * argp;
18886 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
18887 if (SWIG_arg_fail(2)) SWIG_fail;
18888 if (argp == NULL) {
18889 SWIG_null_ref("wxSize");
18890 }
18891 if (SWIG_arg_fail(2)) SWIG_fail;
18892 arg2 = *argp;
18893 }
18894 {
18895 PyThreadState* __tstate = wxPyBeginAllowThreads();
18896 wxSizeEvent_SetSize(arg1,arg2);
18897
18898 wxPyEndAllowThreads(__tstate);
18899 if (PyErr_Occurred()) SWIG_fail;
18900 }
18901 Py_INCREF(Py_None); resultobj = Py_None;
18902 return resultobj;
18903 fail:
18904 return NULL;
18905 }
18906
18907
18908 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
18909 PyObject *resultobj;
18910 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18911 wxSize *arg2 = (wxSize *) 0 ;
18912 PyObject * obj0 = 0 ;
18913 PyObject * obj1 = 0 ;
18914 char *kwnames[] = {
18915 (char *) "self",(char *) "m_size", NULL
18916 };
18917
18918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
18919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18920 if (SWIG_arg_fail(1)) SWIG_fail;
18921 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
18922 if (SWIG_arg_fail(2)) SWIG_fail;
18923 if (arg1) (arg1)->m_size = *arg2;
18924
18925 Py_INCREF(Py_None); resultobj = Py_None;
18926 return resultobj;
18927 fail:
18928 return NULL;
18929 }
18930
18931
18932 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
18933 PyObject *resultobj;
18934 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18935 wxSize *result;
18936 PyObject * obj0 = 0 ;
18937 char *kwnames[] = {
18938 (char *) "self", NULL
18939 };
18940
18941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
18942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18943 if (SWIG_arg_fail(1)) SWIG_fail;
18944 result = (wxSize *)& ((arg1)->m_size);
18945
18946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
18947 return resultobj;
18948 fail:
18949 return NULL;
18950 }
18951
18952
18953 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
18954 PyObject *resultobj;
18955 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18956 wxRect *arg2 = (wxRect *) 0 ;
18957 PyObject * obj0 = 0 ;
18958 PyObject * obj1 = 0 ;
18959 char *kwnames[] = {
18960 (char *) "self",(char *) "m_rect", NULL
18961 };
18962
18963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
18964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18965 if (SWIG_arg_fail(1)) SWIG_fail;
18966 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18967 if (SWIG_arg_fail(2)) SWIG_fail;
18968 if (arg1) (arg1)->m_rect = *arg2;
18969
18970 Py_INCREF(Py_None); resultobj = Py_None;
18971 return resultobj;
18972 fail:
18973 return NULL;
18974 }
18975
18976
18977 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
18978 PyObject *resultobj;
18979 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18980 wxRect *result;
18981 PyObject * obj0 = 0 ;
18982 char *kwnames[] = {
18983 (char *) "self", NULL
18984 };
18985
18986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
18987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18988 if (SWIG_arg_fail(1)) SWIG_fail;
18989 result = (wxRect *)& ((arg1)->m_rect);
18990
18991 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
18992 return resultobj;
18993 fail:
18994 return NULL;
18995 }
18996
18997
18998 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
18999 PyObject *obj;
19000 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19001 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19002 Py_INCREF(obj);
19003 return Py_BuildValue((char *)"");
19004 }
19005 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19006 PyObject *resultobj;
19007 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19008 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19009 int arg2 = (int) 0 ;
19010 wxMoveEvent *result;
19011 wxPoint temp1 ;
19012 PyObject * obj0 = 0 ;
19013 PyObject * obj1 = 0 ;
19014 char *kwnames[] = {
19015 (char *) "pos",(char *) "winid", NULL
19016 };
19017
19018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19019 if (obj0) {
19020 {
19021 arg1 = &temp1;
19022 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19023 }
19024 }
19025 if (obj1) {
19026 {
19027 arg2 = (int)(SWIG_As_int(obj1));
19028 if (SWIG_arg_fail(2)) SWIG_fail;
19029 }
19030 }
19031 {
19032 PyThreadState* __tstate = wxPyBeginAllowThreads();
19033 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19034
19035 wxPyEndAllowThreads(__tstate);
19036 if (PyErr_Occurred()) SWIG_fail;
19037 }
19038 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19039 return resultobj;
19040 fail:
19041 return NULL;
19042 }
19043
19044
19045 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19046 PyObject *resultobj;
19047 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19048 wxPoint result;
19049 PyObject * obj0 = 0 ;
19050 char *kwnames[] = {
19051 (char *) "self", NULL
19052 };
19053
19054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19056 if (SWIG_arg_fail(1)) SWIG_fail;
19057 {
19058 PyThreadState* __tstate = wxPyBeginAllowThreads();
19059 result = ((wxMoveEvent const *)arg1)->GetPosition();
19060
19061 wxPyEndAllowThreads(__tstate);
19062 if (PyErr_Occurred()) SWIG_fail;
19063 }
19064 {
19065 wxPoint * resultptr;
19066 resultptr = new wxPoint((wxPoint &)(result));
19067 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19068 }
19069 return resultobj;
19070 fail:
19071 return NULL;
19072 }
19073
19074
19075 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19076 PyObject *resultobj;
19077 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19078 wxRect result;
19079 PyObject * obj0 = 0 ;
19080 char *kwnames[] = {
19081 (char *) "self", NULL
19082 };
19083
19084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19086 if (SWIG_arg_fail(1)) SWIG_fail;
19087 {
19088 PyThreadState* __tstate = wxPyBeginAllowThreads();
19089 result = ((wxMoveEvent const *)arg1)->GetRect();
19090
19091 wxPyEndAllowThreads(__tstate);
19092 if (PyErr_Occurred()) SWIG_fail;
19093 }
19094 {
19095 wxRect * resultptr;
19096 resultptr = new wxRect((wxRect &)(result));
19097 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19098 }
19099 return resultobj;
19100 fail:
19101 return NULL;
19102 }
19103
19104
19105 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19106 PyObject *resultobj;
19107 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19108 wxRect *arg2 = 0 ;
19109 wxRect temp2 ;
19110 PyObject * obj0 = 0 ;
19111 PyObject * obj1 = 0 ;
19112 char *kwnames[] = {
19113 (char *) "self",(char *) "rect", NULL
19114 };
19115
19116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19118 if (SWIG_arg_fail(1)) SWIG_fail;
19119 {
19120 arg2 = &temp2;
19121 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19122 }
19123 {
19124 PyThreadState* __tstate = wxPyBeginAllowThreads();
19125 (arg1)->SetRect((wxRect const &)*arg2);
19126
19127 wxPyEndAllowThreads(__tstate);
19128 if (PyErr_Occurred()) SWIG_fail;
19129 }
19130 Py_INCREF(Py_None); resultobj = Py_None;
19131 return resultobj;
19132 fail:
19133 return NULL;
19134 }
19135
19136
19137 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19138 PyObject *resultobj;
19139 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19140 wxPoint *arg2 = 0 ;
19141 wxPoint temp2 ;
19142 PyObject * obj0 = 0 ;
19143 PyObject * obj1 = 0 ;
19144 char *kwnames[] = {
19145 (char *) "self",(char *) "pos", NULL
19146 };
19147
19148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19150 if (SWIG_arg_fail(1)) SWIG_fail;
19151 {
19152 arg2 = &temp2;
19153 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19154 }
19155 {
19156 PyThreadState* __tstate = wxPyBeginAllowThreads();
19157 (arg1)->SetPosition((wxPoint const &)*arg2);
19158
19159 wxPyEndAllowThreads(__tstate);
19160 if (PyErr_Occurred()) SWIG_fail;
19161 }
19162 Py_INCREF(Py_None); resultobj = Py_None;
19163 return resultobj;
19164 fail:
19165 return NULL;
19166 }
19167
19168
19169 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19170 PyObject *obj;
19171 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19172 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19173 Py_INCREF(obj);
19174 return Py_BuildValue((char *)"");
19175 }
19176 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19177 PyObject *resultobj;
19178 int arg1 = (int) 0 ;
19179 wxPaintEvent *result;
19180 PyObject * obj0 = 0 ;
19181 char *kwnames[] = {
19182 (char *) "Id", NULL
19183 };
19184
19185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19186 if (obj0) {
19187 {
19188 arg1 = (int)(SWIG_As_int(obj0));
19189 if (SWIG_arg_fail(1)) SWIG_fail;
19190 }
19191 }
19192 {
19193 PyThreadState* __tstate = wxPyBeginAllowThreads();
19194 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19195
19196 wxPyEndAllowThreads(__tstate);
19197 if (PyErr_Occurred()) SWIG_fail;
19198 }
19199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19200 return resultobj;
19201 fail:
19202 return NULL;
19203 }
19204
19205
19206 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19207 PyObject *obj;
19208 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19209 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19210 Py_INCREF(obj);
19211 return Py_BuildValue((char *)"");
19212 }
19213 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19214 PyObject *resultobj;
19215 int arg1 = (int) 0 ;
19216 wxNcPaintEvent *result;
19217 PyObject * obj0 = 0 ;
19218 char *kwnames[] = {
19219 (char *) "winid", NULL
19220 };
19221
19222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19223 if (obj0) {
19224 {
19225 arg1 = (int)(SWIG_As_int(obj0));
19226 if (SWIG_arg_fail(1)) SWIG_fail;
19227 }
19228 }
19229 {
19230 PyThreadState* __tstate = wxPyBeginAllowThreads();
19231 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19232
19233 wxPyEndAllowThreads(__tstate);
19234 if (PyErr_Occurred()) SWIG_fail;
19235 }
19236 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19237 return resultobj;
19238 fail:
19239 return NULL;
19240 }
19241
19242
19243 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19244 PyObject *obj;
19245 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19246 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19247 Py_INCREF(obj);
19248 return Py_BuildValue((char *)"");
19249 }
19250 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19251 PyObject *resultobj;
19252 int arg1 = (int) 0 ;
19253 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19254 wxEraseEvent *result;
19255 PyObject * obj0 = 0 ;
19256 PyObject * obj1 = 0 ;
19257 char *kwnames[] = {
19258 (char *) "Id",(char *) "dc", NULL
19259 };
19260
19261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19262 if (obj0) {
19263 {
19264 arg1 = (int)(SWIG_As_int(obj0));
19265 if (SWIG_arg_fail(1)) SWIG_fail;
19266 }
19267 }
19268 if (obj1) {
19269 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19270 if (SWIG_arg_fail(2)) SWIG_fail;
19271 }
19272 {
19273 PyThreadState* __tstate = wxPyBeginAllowThreads();
19274 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19275
19276 wxPyEndAllowThreads(__tstate);
19277 if (PyErr_Occurred()) SWIG_fail;
19278 }
19279 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19280 return resultobj;
19281 fail:
19282 return NULL;
19283 }
19284
19285
19286 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19287 PyObject *resultobj;
19288 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19289 wxDC *result;
19290 PyObject * obj0 = 0 ;
19291 char *kwnames[] = {
19292 (char *) "self", NULL
19293 };
19294
19295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19297 if (SWIG_arg_fail(1)) SWIG_fail;
19298 {
19299 PyThreadState* __tstate = wxPyBeginAllowThreads();
19300 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19301
19302 wxPyEndAllowThreads(__tstate);
19303 if (PyErr_Occurred()) SWIG_fail;
19304 }
19305 {
19306 resultobj = wxPyMake_wxObject(result, 0);
19307 }
19308 return resultobj;
19309 fail:
19310 return NULL;
19311 }
19312
19313
19314 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19315 PyObject *obj;
19316 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19317 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19318 Py_INCREF(obj);
19319 return Py_BuildValue((char *)"");
19320 }
19321 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19322 PyObject *resultobj;
19323 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19324 int arg2 = (int) 0 ;
19325 wxFocusEvent *result;
19326 PyObject * obj0 = 0 ;
19327 PyObject * obj1 = 0 ;
19328 char *kwnames[] = {
19329 (char *) "type",(char *) "winid", NULL
19330 };
19331
19332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19333 if (obj0) {
19334 {
19335 arg1 = (wxEventType)(SWIG_As_int(obj0));
19336 if (SWIG_arg_fail(1)) SWIG_fail;
19337 }
19338 }
19339 if (obj1) {
19340 {
19341 arg2 = (int)(SWIG_As_int(obj1));
19342 if (SWIG_arg_fail(2)) SWIG_fail;
19343 }
19344 }
19345 {
19346 PyThreadState* __tstate = wxPyBeginAllowThreads();
19347 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19348
19349 wxPyEndAllowThreads(__tstate);
19350 if (PyErr_Occurred()) SWIG_fail;
19351 }
19352 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19353 return resultobj;
19354 fail:
19355 return NULL;
19356 }
19357
19358
19359 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19360 PyObject *resultobj;
19361 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19362 wxWindow *result;
19363 PyObject * obj0 = 0 ;
19364 char *kwnames[] = {
19365 (char *) "self", NULL
19366 };
19367
19368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19370 if (SWIG_arg_fail(1)) SWIG_fail;
19371 {
19372 PyThreadState* __tstate = wxPyBeginAllowThreads();
19373 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19374
19375 wxPyEndAllowThreads(__tstate);
19376 if (PyErr_Occurred()) SWIG_fail;
19377 }
19378 {
19379 resultobj = wxPyMake_wxObject(result, 0);
19380 }
19381 return resultobj;
19382 fail:
19383 return NULL;
19384 }
19385
19386
19387 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19388 PyObject *resultobj;
19389 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19390 wxWindow *arg2 = (wxWindow *) 0 ;
19391 PyObject * obj0 = 0 ;
19392 PyObject * obj1 = 0 ;
19393 char *kwnames[] = {
19394 (char *) "self",(char *) "win", NULL
19395 };
19396
19397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19399 if (SWIG_arg_fail(1)) SWIG_fail;
19400 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19401 if (SWIG_arg_fail(2)) SWIG_fail;
19402 {
19403 PyThreadState* __tstate = wxPyBeginAllowThreads();
19404 (arg1)->SetWindow(arg2);
19405
19406 wxPyEndAllowThreads(__tstate);
19407 if (PyErr_Occurred()) SWIG_fail;
19408 }
19409 Py_INCREF(Py_None); resultobj = Py_None;
19410 return resultobj;
19411 fail:
19412 return NULL;
19413 }
19414
19415
19416 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19417 PyObject *obj;
19418 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19419 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19420 Py_INCREF(obj);
19421 return Py_BuildValue((char *)"");
19422 }
19423 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19424 PyObject *resultobj;
19425 wxWindow *arg1 = (wxWindow *) NULL ;
19426 wxChildFocusEvent *result;
19427 PyObject * obj0 = 0 ;
19428 char *kwnames[] = {
19429 (char *) "win", NULL
19430 };
19431
19432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19433 if (obj0) {
19434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19435 if (SWIG_arg_fail(1)) SWIG_fail;
19436 }
19437 {
19438 PyThreadState* __tstate = wxPyBeginAllowThreads();
19439 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19440
19441 wxPyEndAllowThreads(__tstate);
19442 if (PyErr_Occurred()) SWIG_fail;
19443 }
19444 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19445 return resultobj;
19446 fail:
19447 return NULL;
19448 }
19449
19450
19451 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19452 PyObject *resultobj;
19453 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19454 wxWindow *result;
19455 PyObject * obj0 = 0 ;
19456 char *kwnames[] = {
19457 (char *) "self", NULL
19458 };
19459
19460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19462 if (SWIG_arg_fail(1)) SWIG_fail;
19463 {
19464 PyThreadState* __tstate = wxPyBeginAllowThreads();
19465 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19466
19467 wxPyEndAllowThreads(__tstate);
19468 if (PyErr_Occurred()) SWIG_fail;
19469 }
19470 {
19471 resultobj = wxPyMake_wxObject(result, 0);
19472 }
19473 return resultobj;
19474 fail:
19475 return NULL;
19476 }
19477
19478
19479 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19480 PyObject *obj;
19481 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19482 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19483 Py_INCREF(obj);
19484 return Py_BuildValue((char *)"");
19485 }
19486 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19487 PyObject *resultobj;
19488 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19489 bool arg2 = (bool) true ;
19490 int arg3 = (int) 0 ;
19491 wxActivateEvent *result;
19492 PyObject * obj0 = 0 ;
19493 PyObject * obj1 = 0 ;
19494 PyObject * obj2 = 0 ;
19495 char *kwnames[] = {
19496 (char *) "type",(char *) "active",(char *) "Id", NULL
19497 };
19498
19499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19500 if (obj0) {
19501 {
19502 arg1 = (wxEventType)(SWIG_As_int(obj0));
19503 if (SWIG_arg_fail(1)) SWIG_fail;
19504 }
19505 }
19506 if (obj1) {
19507 {
19508 arg2 = (bool)(SWIG_As_bool(obj1));
19509 if (SWIG_arg_fail(2)) SWIG_fail;
19510 }
19511 }
19512 if (obj2) {
19513 {
19514 arg3 = (int)(SWIG_As_int(obj2));
19515 if (SWIG_arg_fail(3)) SWIG_fail;
19516 }
19517 }
19518 {
19519 PyThreadState* __tstate = wxPyBeginAllowThreads();
19520 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19521
19522 wxPyEndAllowThreads(__tstate);
19523 if (PyErr_Occurred()) SWIG_fail;
19524 }
19525 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19526 return resultobj;
19527 fail:
19528 return NULL;
19529 }
19530
19531
19532 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19533 PyObject *resultobj;
19534 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19535 bool result;
19536 PyObject * obj0 = 0 ;
19537 char *kwnames[] = {
19538 (char *) "self", NULL
19539 };
19540
19541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19543 if (SWIG_arg_fail(1)) SWIG_fail;
19544 {
19545 PyThreadState* __tstate = wxPyBeginAllowThreads();
19546 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19547
19548 wxPyEndAllowThreads(__tstate);
19549 if (PyErr_Occurred()) SWIG_fail;
19550 }
19551 {
19552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19553 }
19554 return resultobj;
19555 fail:
19556 return NULL;
19557 }
19558
19559
19560 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19561 PyObject *obj;
19562 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19563 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19564 Py_INCREF(obj);
19565 return Py_BuildValue((char *)"");
19566 }
19567 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19568 PyObject *resultobj;
19569 int arg1 = (int) 0 ;
19570 wxInitDialogEvent *result;
19571 PyObject * obj0 = 0 ;
19572 char *kwnames[] = {
19573 (char *) "Id", NULL
19574 };
19575
19576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19577 if (obj0) {
19578 {
19579 arg1 = (int)(SWIG_As_int(obj0));
19580 if (SWIG_arg_fail(1)) SWIG_fail;
19581 }
19582 }
19583 {
19584 PyThreadState* __tstate = wxPyBeginAllowThreads();
19585 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19586
19587 wxPyEndAllowThreads(__tstate);
19588 if (PyErr_Occurred()) SWIG_fail;
19589 }
19590 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19591 return resultobj;
19592 fail:
19593 return NULL;
19594 }
19595
19596
19597 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19598 PyObject *obj;
19599 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19600 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19601 Py_INCREF(obj);
19602 return Py_BuildValue((char *)"");
19603 }
19604 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19605 PyObject *resultobj;
19606 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19607 int arg2 = (int) 0 ;
19608 wxMenu *arg3 = (wxMenu *) NULL ;
19609 wxMenuEvent *result;
19610 PyObject * obj0 = 0 ;
19611 PyObject * obj1 = 0 ;
19612 PyObject * obj2 = 0 ;
19613 char *kwnames[] = {
19614 (char *) "type",(char *) "winid",(char *) "menu", NULL
19615 };
19616
19617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19618 if (obj0) {
19619 {
19620 arg1 = (wxEventType)(SWIG_As_int(obj0));
19621 if (SWIG_arg_fail(1)) SWIG_fail;
19622 }
19623 }
19624 if (obj1) {
19625 {
19626 arg2 = (int)(SWIG_As_int(obj1));
19627 if (SWIG_arg_fail(2)) SWIG_fail;
19628 }
19629 }
19630 if (obj2) {
19631 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19632 if (SWIG_arg_fail(3)) SWIG_fail;
19633 }
19634 {
19635 PyThreadState* __tstate = wxPyBeginAllowThreads();
19636 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19637
19638 wxPyEndAllowThreads(__tstate);
19639 if (PyErr_Occurred()) SWIG_fail;
19640 }
19641 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19642 return resultobj;
19643 fail:
19644 return NULL;
19645 }
19646
19647
19648 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19649 PyObject *resultobj;
19650 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19651 int result;
19652 PyObject * obj0 = 0 ;
19653 char *kwnames[] = {
19654 (char *) "self", NULL
19655 };
19656
19657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19659 if (SWIG_arg_fail(1)) SWIG_fail;
19660 {
19661 PyThreadState* __tstate = wxPyBeginAllowThreads();
19662 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19663
19664 wxPyEndAllowThreads(__tstate);
19665 if (PyErr_Occurred()) SWIG_fail;
19666 }
19667 {
19668 resultobj = SWIG_From_int((int)(result));
19669 }
19670 return resultobj;
19671 fail:
19672 return NULL;
19673 }
19674
19675
19676 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19677 PyObject *resultobj;
19678 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19679 bool result;
19680 PyObject * obj0 = 0 ;
19681 char *kwnames[] = {
19682 (char *) "self", NULL
19683 };
19684
19685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19687 if (SWIG_arg_fail(1)) SWIG_fail;
19688 {
19689 PyThreadState* __tstate = wxPyBeginAllowThreads();
19690 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19691
19692 wxPyEndAllowThreads(__tstate);
19693 if (PyErr_Occurred()) SWIG_fail;
19694 }
19695 {
19696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19697 }
19698 return resultobj;
19699 fail:
19700 return NULL;
19701 }
19702
19703
19704 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
19705 PyObject *resultobj;
19706 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19707 wxMenu *result;
19708 PyObject * obj0 = 0 ;
19709 char *kwnames[] = {
19710 (char *) "self", NULL
19711 };
19712
19713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
19714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19715 if (SWIG_arg_fail(1)) SWIG_fail;
19716 {
19717 PyThreadState* __tstate = wxPyBeginAllowThreads();
19718 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
19719
19720 wxPyEndAllowThreads(__tstate);
19721 if (PyErr_Occurred()) SWIG_fail;
19722 }
19723 {
19724 resultobj = wxPyMake_wxObject(result, 0);
19725 }
19726 return resultobj;
19727 fail:
19728 return NULL;
19729 }
19730
19731
19732 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
19733 PyObject *obj;
19734 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19735 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
19736 Py_INCREF(obj);
19737 return Py_BuildValue((char *)"");
19738 }
19739 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19740 PyObject *resultobj;
19741 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19742 int arg2 = (int) 0 ;
19743 wxCloseEvent *result;
19744 PyObject * obj0 = 0 ;
19745 PyObject * obj1 = 0 ;
19746 char *kwnames[] = {
19747 (char *) "type",(char *) "winid", NULL
19748 };
19749
19750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
19751 if (obj0) {
19752 {
19753 arg1 = (wxEventType)(SWIG_As_int(obj0));
19754 if (SWIG_arg_fail(1)) SWIG_fail;
19755 }
19756 }
19757 if (obj1) {
19758 {
19759 arg2 = (int)(SWIG_As_int(obj1));
19760 if (SWIG_arg_fail(2)) SWIG_fail;
19761 }
19762 }
19763 {
19764 PyThreadState* __tstate = wxPyBeginAllowThreads();
19765 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
19766
19767 wxPyEndAllowThreads(__tstate);
19768 if (PyErr_Occurred()) SWIG_fail;
19769 }
19770 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
19771 return resultobj;
19772 fail:
19773 return NULL;
19774 }
19775
19776
19777 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19778 PyObject *resultobj;
19779 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19780 bool arg2 ;
19781 PyObject * obj0 = 0 ;
19782 PyObject * obj1 = 0 ;
19783 char *kwnames[] = {
19784 (char *) "self",(char *) "logOff", NULL
19785 };
19786
19787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
19788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19789 if (SWIG_arg_fail(1)) SWIG_fail;
19790 {
19791 arg2 = (bool)(SWIG_As_bool(obj1));
19792 if (SWIG_arg_fail(2)) SWIG_fail;
19793 }
19794 {
19795 PyThreadState* __tstate = wxPyBeginAllowThreads();
19796 (arg1)->SetLoggingOff(arg2);
19797
19798 wxPyEndAllowThreads(__tstate);
19799 if (PyErr_Occurred()) SWIG_fail;
19800 }
19801 Py_INCREF(Py_None); resultobj = Py_None;
19802 return resultobj;
19803 fail:
19804 return NULL;
19805 }
19806
19807
19808 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19809 PyObject *resultobj;
19810 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19811 bool result;
19812 PyObject * obj0 = 0 ;
19813 char *kwnames[] = {
19814 (char *) "self", NULL
19815 };
19816
19817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
19818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19819 if (SWIG_arg_fail(1)) SWIG_fail;
19820 {
19821 PyThreadState* __tstate = wxPyBeginAllowThreads();
19822 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
19823
19824 wxPyEndAllowThreads(__tstate);
19825 if (PyErr_Occurred()) SWIG_fail;
19826 }
19827 {
19828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19829 }
19830 return resultobj;
19831 fail:
19832 return NULL;
19833 }
19834
19835
19836 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
19837 PyObject *resultobj;
19838 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19839 bool arg2 = (bool) true ;
19840 PyObject * obj0 = 0 ;
19841 PyObject * obj1 = 0 ;
19842 char *kwnames[] = {
19843 (char *) "self",(char *) "veto", NULL
19844 };
19845
19846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
19847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19848 if (SWIG_arg_fail(1)) SWIG_fail;
19849 if (obj1) {
19850 {
19851 arg2 = (bool)(SWIG_As_bool(obj1));
19852 if (SWIG_arg_fail(2)) SWIG_fail;
19853 }
19854 }
19855 {
19856 PyThreadState* __tstate = wxPyBeginAllowThreads();
19857 (arg1)->Veto(arg2);
19858
19859 wxPyEndAllowThreads(__tstate);
19860 if (PyErr_Occurred()) SWIG_fail;
19861 }
19862 Py_INCREF(Py_None); resultobj = Py_None;
19863 return resultobj;
19864 fail:
19865 return NULL;
19866 }
19867
19868
19869 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19870 PyObject *resultobj;
19871 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19872 bool arg2 ;
19873 PyObject * obj0 = 0 ;
19874 PyObject * obj1 = 0 ;
19875 char *kwnames[] = {
19876 (char *) "self",(char *) "canVeto", NULL
19877 };
19878
19879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
19880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19881 if (SWIG_arg_fail(1)) SWIG_fail;
19882 {
19883 arg2 = (bool)(SWIG_As_bool(obj1));
19884 if (SWIG_arg_fail(2)) SWIG_fail;
19885 }
19886 {
19887 PyThreadState* __tstate = wxPyBeginAllowThreads();
19888 (arg1)->SetCanVeto(arg2);
19889
19890 wxPyEndAllowThreads(__tstate);
19891 if (PyErr_Occurred()) SWIG_fail;
19892 }
19893 Py_INCREF(Py_None); resultobj = Py_None;
19894 return resultobj;
19895 fail:
19896 return NULL;
19897 }
19898
19899
19900 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19901 PyObject *resultobj;
19902 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19903 bool result;
19904 PyObject * obj0 = 0 ;
19905 char *kwnames[] = {
19906 (char *) "self", NULL
19907 };
19908
19909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
19910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19911 if (SWIG_arg_fail(1)) SWIG_fail;
19912 {
19913 PyThreadState* __tstate = wxPyBeginAllowThreads();
19914 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
19915
19916 wxPyEndAllowThreads(__tstate);
19917 if (PyErr_Occurred()) SWIG_fail;
19918 }
19919 {
19920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19921 }
19922 return resultobj;
19923 fail:
19924 return NULL;
19925 }
19926
19927
19928 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19929 PyObject *resultobj;
19930 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19931 bool result;
19932 PyObject * obj0 = 0 ;
19933 char *kwnames[] = {
19934 (char *) "self", NULL
19935 };
19936
19937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
19938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19939 if (SWIG_arg_fail(1)) SWIG_fail;
19940 {
19941 PyThreadState* __tstate = wxPyBeginAllowThreads();
19942 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
19943
19944 wxPyEndAllowThreads(__tstate);
19945 if (PyErr_Occurred()) SWIG_fail;
19946 }
19947 {
19948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19949 }
19950 return resultobj;
19951 fail:
19952 return NULL;
19953 }
19954
19955
19956 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
19957 PyObject *obj;
19958 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19959 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
19960 Py_INCREF(obj);
19961 return Py_BuildValue((char *)"");
19962 }
19963 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19964 PyObject *resultobj;
19965 int arg1 = (int) 0 ;
19966 bool arg2 = (bool) false ;
19967 wxShowEvent *result;
19968 PyObject * obj0 = 0 ;
19969 PyObject * obj1 = 0 ;
19970 char *kwnames[] = {
19971 (char *) "winid",(char *) "show", NULL
19972 };
19973
19974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
19975 if (obj0) {
19976 {
19977 arg1 = (int)(SWIG_As_int(obj0));
19978 if (SWIG_arg_fail(1)) SWIG_fail;
19979 }
19980 }
19981 if (obj1) {
19982 {
19983 arg2 = (bool)(SWIG_As_bool(obj1));
19984 if (SWIG_arg_fail(2)) SWIG_fail;
19985 }
19986 }
19987 {
19988 PyThreadState* __tstate = wxPyBeginAllowThreads();
19989 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
19990
19991 wxPyEndAllowThreads(__tstate);
19992 if (PyErr_Occurred()) SWIG_fail;
19993 }
19994 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
19995 return resultobj;
19996 fail:
19997 return NULL;
19998 }
19999
20000
20001 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20002 PyObject *resultobj;
20003 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20004 bool arg2 ;
20005 PyObject * obj0 = 0 ;
20006 PyObject * obj1 = 0 ;
20007 char *kwnames[] = {
20008 (char *) "self",(char *) "show", NULL
20009 };
20010
20011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20013 if (SWIG_arg_fail(1)) SWIG_fail;
20014 {
20015 arg2 = (bool)(SWIG_As_bool(obj1));
20016 if (SWIG_arg_fail(2)) SWIG_fail;
20017 }
20018 {
20019 PyThreadState* __tstate = wxPyBeginAllowThreads();
20020 (arg1)->SetShow(arg2);
20021
20022 wxPyEndAllowThreads(__tstate);
20023 if (PyErr_Occurred()) SWIG_fail;
20024 }
20025 Py_INCREF(Py_None); resultobj = Py_None;
20026 return resultobj;
20027 fail:
20028 return NULL;
20029 }
20030
20031
20032 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20033 PyObject *resultobj;
20034 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20035 bool result;
20036 PyObject * obj0 = 0 ;
20037 char *kwnames[] = {
20038 (char *) "self", NULL
20039 };
20040
20041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20043 if (SWIG_arg_fail(1)) SWIG_fail;
20044 {
20045 PyThreadState* __tstate = wxPyBeginAllowThreads();
20046 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20047
20048 wxPyEndAllowThreads(__tstate);
20049 if (PyErr_Occurred()) SWIG_fail;
20050 }
20051 {
20052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20053 }
20054 return resultobj;
20055 fail:
20056 return NULL;
20057 }
20058
20059
20060 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20061 PyObject *obj;
20062 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20063 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20064 Py_INCREF(obj);
20065 return Py_BuildValue((char *)"");
20066 }
20067 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20068 PyObject *resultobj;
20069 int arg1 = (int) 0 ;
20070 bool arg2 = (bool) true ;
20071 wxIconizeEvent *result;
20072 PyObject * obj0 = 0 ;
20073 PyObject * obj1 = 0 ;
20074 char *kwnames[] = {
20075 (char *) "id",(char *) "iconized", NULL
20076 };
20077
20078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20079 if (obj0) {
20080 {
20081 arg1 = (int)(SWIG_As_int(obj0));
20082 if (SWIG_arg_fail(1)) SWIG_fail;
20083 }
20084 }
20085 if (obj1) {
20086 {
20087 arg2 = (bool)(SWIG_As_bool(obj1));
20088 if (SWIG_arg_fail(2)) SWIG_fail;
20089 }
20090 }
20091 {
20092 PyThreadState* __tstate = wxPyBeginAllowThreads();
20093 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20094
20095 wxPyEndAllowThreads(__tstate);
20096 if (PyErr_Occurred()) SWIG_fail;
20097 }
20098 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20099 return resultobj;
20100 fail:
20101 return NULL;
20102 }
20103
20104
20105 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20106 PyObject *resultobj;
20107 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20108 bool result;
20109 PyObject * obj0 = 0 ;
20110 char *kwnames[] = {
20111 (char *) "self", NULL
20112 };
20113
20114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20116 if (SWIG_arg_fail(1)) SWIG_fail;
20117 {
20118 PyThreadState* __tstate = wxPyBeginAllowThreads();
20119 result = (bool)(arg1)->Iconized();
20120
20121 wxPyEndAllowThreads(__tstate);
20122 if (PyErr_Occurred()) SWIG_fail;
20123 }
20124 {
20125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20126 }
20127 return resultobj;
20128 fail:
20129 return NULL;
20130 }
20131
20132
20133 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20134 PyObject *obj;
20135 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20136 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20137 Py_INCREF(obj);
20138 return Py_BuildValue((char *)"");
20139 }
20140 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20141 PyObject *resultobj;
20142 int arg1 = (int) 0 ;
20143 wxMaximizeEvent *result;
20144 PyObject * obj0 = 0 ;
20145 char *kwnames[] = {
20146 (char *) "id", NULL
20147 };
20148
20149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20150 if (obj0) {
20151 {
20152 arg1 = (int)(SWIG_As_int(obj0));
20153 if (SWIG_arg_fail(1)) SWIG_fail;
20154 }
20155 }
20156 {
20157 PyThreadState* __tstate = wxPyBeginAllowThreads();
20158 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20159
20160 wxPyEndAllowThreads(__tstate);
20161 if (PyErr_Occurred()) SWIG_fail;
20162 }
20163 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20164 return resultobj;
20165 fail:
20166 return NULL;
20167 }
20168
20169
20170 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20171 PyObject *obj;
20172 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20173 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20174 Py_INCREF(obj);
20175 return Py_BuildValue((char *)"");
20176 }
20177 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20178 PyObject *resultobj;
20179 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20180 wxPoint result;
20181 PyObject * obj0 = 0 ;
20182 char *kwnames[] = {
20183 (char *) "self", NULL
20184 };
20185
20186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20188 if (SWIG_arg_fail(1)) SWIG_fail;
20189 {
20190 PyThreadState* __tstate = wxPyBeginAllowThreads();
20191 result = (arg1)->GetPosition();
20192
20193 wxPyEndAllowThreads(__tstate);
20194 if (PyErr_Occurred()) SWIG_fail;
20195 }
20196 {
20197 wxPoint * resultptr;
20198 resultptr = new wxPoint((wxPoint &)(result));
20199 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20200 }
20201 return resultobj;
20202 fail:
20203 return NULL;
20204 }
20205
20206
20207 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20208 PyObject *resultobj;
20209 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20210 int result;
20211 PyObject * obj0 = 0 ;
20212 char *kwnames[] = {
20213 (char *) "self", NULL
20214 };
20215
20216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20218 if (SWIG_arg_fail(1)) SWIG_fail;
20219 {
20220 PyThreadState* __tstate = wxPyBeginAllowThreads();
20221 result = (int)(arg1)->GetNumberOfFiles();
20222
20223 wxPyEndAllowThreads(__tstate);
20224 if (PyErr_Occurred()) SWIG_fail;
20225 }
20226 {
20227 resultobj = SWIG_From_int((int)(result));
20228 }
20229 return resultobj;
20230 fail:
20231 return NULL;
20232 }
20233
20234
20235 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20236 PyObject *resultobj;
20237 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20238 PyObject *result;
20239 PyObject * obj0 = 0 ;
20240 char *kwnames[] = {
20241 (char *) "self", NULL
20242 };
20243
20244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20246 if (SWIG_arg_fail(1)) SWIG_fail;
20247 {
20248 PyThreadState* __tstate = wxPyBeginAllowThreads();
20249 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20250
20251 wxPyEndAllowThreads(__tstate);
20252 if (PyErr_Occurred()) SWIG_fail;
20253 }
20254 resultobj = result;
20255 return resultobj;
20256 fail:
20257 return NULL;
20258 }
20259
20260
20261 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20262 PyObject *obj;
20263 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20264 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20265 Py_INCREF(obj);
20266 return Py_BuildValue((char *)"");
20267 }
20268 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20269 PyObject *resultobj;
20270 int arg1 = (int) 0 ;
20271 wxUpdateUIEvent *result;
20272 PyObject * obj0 = 0 ;
20273 char *kwnames[] = {
20274 (char *) "commandId", NULL
20275 };
20276
20277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20278 if (obj0) {
20279 {
20280 arg1 = (int)(SWIG_As_int(obj0));
20281 if (SWIG_arg_fail(1)) SWIG_fail;
20282 }
20283 }
20284 {
20285 PyThreadState* __tstate = wxPyBeginAllowThreads();
20286 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20287
20288 wxPyEndAllowThreads(__tstate);
20289 if (PyErr_Occurred()) SWIG_fail;
20290 }
20291 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20292 return resultobj;
20293 fail:
20294 return NULL;
20295 }
20296
20297
20298 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20299 PyObject *resultobj;
20300 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20301 bool result;
20302 PyObject * obj0 = 0 ;
20303 char *kwnames[] = {
20304 (char *) "self", NULL
20305 };
20306
20307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20309 if (SWIG_arg_fail(1)) SWIG_fail;
20310 {
20311 PyThreadState* __tstate = wxPyBeginAllowThreads();
20312 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20313
20314 wxPyEndAllowThreads(__tstate);
20315 if (PyErr_Occurred()) SWIG_fail;
20316 }
20317 {
20318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20319 }
20320 return resultobj;
20321 fail:
20322 return NULL;
20323 }
20324
20325
20326 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20327 PyObject *resultobj;
20328 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20329 bool result;
20330 PyObject * obj0 = 0 ;
20331 char *kwnames[] = {
20332 (char *) "self", NULL
20333 };
20334
20335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20337 if (SWIG_arg_fail(1)) SWIG_fail;
20338 {
20339 PyThreadState* __tstate = wxPyBeginAllowThreads();
20340 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20341
20342 wxPyEndAllowThreads(__tstate);
20343 if (PyErr_Occurred()) SWIG_fail;
20344 }
20345 {
20346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20347 }
20348 return resultobj;
20349 fail:
20350 return NULL;
20351 }
20352
20353
20354 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20355 PyObject *resultobj;
20356 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20357 wxString result;
20358 PyObject * obj0 = 0 ;
20359 char *kwnames[] = {
20360 (char *) "self", NULL
20361 };
20362
20363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20365 if (SWIG_arg_fail(1)) SWIG_fail;
20366 {
20367 PyThreadState* __tstate = wxPyBeginAllowThreads();
20368 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20369
20370 wxPyEndAllowThreads(__tstate);
20371 if (PyErr_Occurred()) SWIG_fail;
20372 }
20373 {
20374 #if wxUSE_UNICODE
20375 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20376 #else
20377 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20378 #endif
20379 }
20380 return resultobj;
20381 fail:
20382 return NULL;
20383 }
20384
20385
20386 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20387 PyObject *resultobj;
20388 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20389 bool result;
20390 PyObject * obj0 = 0 ;
20391 char *kwnames[] = {
20392 (char *) "self", NULL
20393 };
20394
20395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20397 if (SWIG_arg_fail(1)) SWIG_fail;
20398 {
20399 PyThreadState* __tstate = wxPyBeginAllowThreads();
20400 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20401
20402 wxPyEndAllowThreads(__tstate);
20403 if (PyErr_Occurred()) SWIG_fail;
20404 }
20405 {
20406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20407 }
20408 return resultobj;
20409 fail:
20410 return NULL;
20411 }
20412
20413
20414 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20415 PyObject *resultobj;
20416 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20417 bool result;
20418 PyObject * obj0 = 0 ;
20419 char *kwnames[] = {
20420 (char *) "self", NULL
20421 };
20422
20423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20425 if (SWIG_arg_fail(1)) SWIG_fail;
20426 {
20427 PyThreadState* __tstate = wxPyBeginAllowThreads();
20428 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20429
20430 wxPyEndAllowThreads(__tstate);
20431 if (PyErr_Occurred()) SWIG_fail;
20432 }
20433 {
20434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20435 }
20436 return resultobj;
20437 fail:
20438 return NULL;
20439 }
20440
20441
20442 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20443 PyObject *resultobj;
20444 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20445 bool result;
20446 PyObject * obj0 = 0 ;
20447 char *kwnames[] = {
20448 (char *) "self", NULL
20449 };
20450
20451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20453 if (SWIG_arg_fail(1)) SWIG_fail;
20454 {
20455 PyThreadState* __tstate = wxPyBeginAllowThreads();
20456 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20457
20458 wxPyEndAllowThreads(__tstate);
20459 if (PyErr_Occurred()) SWIG_fail;
20460 }
20461 {
20462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20463 }
20464 return resultobj;
20465 fail:
20466 return NULL;
20467 }
20468
20469
20470 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20471 PyObject *resultobj;
20472 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20473 bool arg2 ;
20474 PyObject * obj0 = 0 ;
20475 PyObject * obj1 = 0 ;
20476 char *kwnames[] = {
20477 (char *) "self",(char *) "check", NULL
20478 };
20479
20480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20482 if (SWIG_arg_fail(1)) SWIG_fail;
20483 {
20484 arg2 = (bool)(SWIG_As_bool(obj1));
20485 if (SWIG_arg_fail(2)) SWIG_fail;
20486 }
20487 {
20488 PyThreadState* __tstate = wxPyBeginAllowThreads();
20489 (arg1)->Check(arg2);
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_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20502 PyObject *resultobj;
20503 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20504 bool arg2 ;
20505 PyObject * obj0 = 0 ;
20506 PyObject * obj1 = 0 ;
20507 char *kwnames[] = {
20508 (char *) "self",(char *) "enable", NULL
20509 };
20510
20511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20513 if (SWIG_arg_fail(1)) SWIG_fail;
20514 {
20515 arg2 = (bool)(SWIG_As_bool(obj1));
20516 if (SWIG_arg_fail(2)) SWIG_fail;
20517 }
20518 {
20519 PyThreadState* __tstate = wxPyBeginAllowThreads();
20520 (arg1)->Enable(arg2);
20521
20522 wxPyEndAllowThreads(__tstate);
20523 if (PyErr_Occurred()) SWIG_fail;
20524 }
20525 Py_INCREF(Py_None); resultobj = Py_None;
20526 return resultobj;
20527 fail:
20528 return NULL;
20529 }
20530
20531
20532 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20533 PyObject *resultobj;
20534 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20535 wxString *arg2 = 0 ;
20536 bool temp2 = false ;
20537 PyObject * obj0 = 0 ;
20538 PyObject * obj1 = 0 ;
20539 char *kwnames[] = {
20540 (char *) "self",(char *) "text", NULL
20541 };
20542
20543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20545 if (SWIG_arg_fail(1)) SWIG_fail;
20546 {
20547 arg2 = wxString_in_helper(obj1);
20548 if (arg2 == NULL) SWIG_fail;
20549 temp2 = true;
20550 }
20551 {
20552 PyThreadState* __tstate = wxPyBeginAllowThreads();
20553 (arg1)->SetText((wxString const &)*arg2);
20554
20555 wxPyEndAllowThreads(__tstate);
20556 if (PyErr_Occurred()) SWIG_fail;
20557 }
20558 Py_INCREF(Py_None); resultobj = Py_None;
20559 {
20560 if (temp2)
20561 delete arg2;
20562 }
20563 return resultobj;
20564 fail:
20565 {
20566 if (temp2)
20567 delete arg2;
20568 }
20569 return NULL;
20570 }
20571
20572
20573 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20574 PyObject *resultobj;
20575 long arg1 ;
20576 PyObject * obj0 = 0 ;
20577 char *kwnames[] = {
20578 (char *) "updateInterval", NULL
20579 };
20580
20581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20582 {
20583 arg1 = (long)(SWIG_As_long(obj0));
20584 if (SWIG_arg_fail(1)) SWIG_fail;
20585 }
20586 {
20587 PyThreadState* __tstate = wxPyBeginAllowThreads();
20588 wxUpdateUIEvent::SetUpdateInterval(arg1);
20589
20590 wxPyEndAllowThreads(__tstate);
20591 if (PyErr_Occurred()) SWIG_fail;
20592 }
20593 Py_INCREF(Py_None); resultobj = Py_None;
20594 return resultobj;
20595 fail:
20596 return NULL;
20597 }
20598
20599
20600 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20601 PyObject *resultobj;
20602 long result;
20603 char *kwnames[] = {
20604 NULL
20605 };
20606
20607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20608 {
20609 PyThreadState* __tstate = wxPyBeginAllowThreads();
20610 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20611
20612 wxPyEndAllowThreads(__tstate);
20613 if (PyErr_Occurred()) SWIG_fail;
20614 }
20615 {
20616 resultobj = SWIG_From_long((long)(result));
20617 }
20618 return resultobj;
20619 fail:
20620 return NULL;
20621 }
20622
20623
20624 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20625 PyObject *resultobj;
20626 wxWindow *arg1 = (wxWindow *) 0 ;
20627 bool result;
20628 PyObject * obj0 = 0 ;
20629 char *kwnames[] = {
20630 (char *) "win", NULL
20631 };
20632
20633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20635 if (SWIG_arg_fail(1)) SWIG_fail;
20636 {
20637 PyThreadState* __tstate = wxPyBeginAllowThreads();
20638 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20639
20640 wxPyEndAllowThreads(__tstate);
20641 if (PyErr_Occurred()) SWIG_fail;
20642 }
20643 {
20644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20645 }
20646 return resultobj;
20647 fail:
20648 return NULL;
20649 }
20650
20651
20652 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20653 PyObject *resultobj;
20654 char *kwnames[] = {
20655 NULL
20656 };
20657
20658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20659 {
20660 PyThreadState* __tstate = wxPyBeginAllowThreads();
20661 wxUpdateUIEvent::ResetUpdateTime();
20662
20663 wxPyEndAllowThreads(__tstate);
20664 if (PyErr_Occurred()) SWIG_fail;
20665 }
20666 Py_INCREF(Py_None); resultobj = Py_None;
20667 return resultobj;
20668 fail:
20669 return NULL;
20670 }
20671
20672
20673 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20674 PyObject *resultobj;
20675 wxUpdateUIMode arg1 ;
20676 PyObject * obj0 = 0 ;
20677 char *kwnames[] = {
20678 (char *) "mode", NULL
20679 };
20680
20681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20682 {
20683 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20684 if (SWIG_arg_fail(1)) SWIG_fail;
20685 }
20686 {
20687 PyThreadState* __tstate = wxPyBeginAllowThreads();
20688 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20689
20690 wxPyEndAllowThreads(__tstate);
20691 if (PyErr_Occurred()) SWIG_fail;
20692 }
20693 Py_INCREF(Py_None); resultobj = Py_None;
20694 return resultobj;
20695 fail:
20696 return NULL;
20697 }
20698
20699
20700 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20701 PyObject *resultobj;
20702 wxUpdateUIMode result;
20703 char *kwnames[] = {
20704 NULL
20705 };
20706
20707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
20708 {
20709 PyThreadState* __tstate = wxPyBeginAllowThreads();
20710 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
20711
20712 wxPyEndAllowThreads(__tstate);
20713 if (PyErr_Occurred()) SWIG_fail;
20714 }
20715 resultobj = SWIG_From_int((result));
20716 return resultobj;
20717 fail:
20718 return NULL;
20719 }
20720
20721
20722 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
20723 PyObject *obj;
20724 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20725 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
20726 Py_INCREF(obj);
20727 return Py_BuildValue((char *)"");
20728 }
20729 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20730 PyObject *resultobj;
20731 wxSysColourChangedEvent *result;
20732 char *kwnames[] = {
20733 NULL
20734 };
20735
20736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
20737 {
20738 PyThreadState* __tstate = wxPyBeginAllowThreads();
20739 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
20740
20741 wxPyEndAllowThreads(__tstate);
20742 if (PyErr_Occurred()) SWIG_fail;
20743 }
20744 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
20745 return resultobj;
20746 fail:
20747 return NULL;
20748 }
20749
20750
20751 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
20752 PyObject *obj;
20753 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20754 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
20755 Py_INCREF(obj);
20756 return Py_BuildValue((char *)"");
20757 }
20758 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20759 PyObject *resultobj;
20760 int arg1 = (int) 0 ;
20761 wxWindow *arg2 = (wxWindow *) NULL ;
20762 wxMouseCaptureChangedEvent *result;
20763 PyObject * obj0 = 0 ;
20764 PyObject * obj1 = 0 ;
20765 char *kwnames[] = {
20766 (char *) "winid",(char *) "gainedCapture", NULL
20767 };
20768
20769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
20770 if (obj0) {
20771 {
20772 arg1 = (int)(SWIG_As_int(obj0));
20773 if (SWIG_arg_fail(1)) SWIG_fail;
20774 }
20775 }
20776 if (obj1) {
20777 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20778 if (SWIG_arg_fail(2)) SWIG_fail;
20779 }
20780 {
20781 PyThreadState* __tstate = wxPyBeginAllowThreads();
20782 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
20783
20784 wxPyEndAllowThreads(__tstate);
20785 if (PyErr_Occurred()) SWIG_fail;
20786 }
20787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
20788 return resultobj;
20789 fail:
20790 return NULL;
20791 }
20792
20793
20794 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20795 PyObject *resultobj;
20796 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
20797 wxWindow *result;
20798 PyObject * obj0 = 0 ;
20799 char *kwnames[] = {
20800 (char *) "self", NULL
20801 };
20802
20803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
20804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20805 if (SWIG_arg_fail(1)) SWIG_fail;
20806 {
20807 PyThreadState* __tstate = wxPyBeginAllowThreads();
20808 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
20809
20810 wxPyEndAllowThreads(__tstate);
20811 if (PyErr_Occurred()) SWIG_fail;
20812 }
20813 {
20814 resultobj = wxPyMake_wxObject(result, 0);
20815 }
20816 return resultobj;
20817 fail:
20818 return NULL;
20819 }
20820
20821
20822 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
20823 PyObject *obj;
20824 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20825 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
20826 Py_INCREF(obj);
20827 return Py_BuildValue((char *)"");
20828 }
20829 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20830 PyObject *resultobj;
20831 wxDisplayChangedEvent *result;
20832 char *kwnames[] = {
20833 NULL
20834 };
20835
20836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
20837 {
20838 PyThreadState* __tstate = wxPyBeginAllowThreads();
20839 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
20840
20841 wxPyEndAllowThreads(__tstate);
20842 if (PyErr_Occurred()) SWIG_fail;
20843 }
20844 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
20845 return resultobj;
20846 fail:
20847 return NULL;
20848 }
20849
20850
20851 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
20852 PyObject *obj;
20853 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20854 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
20855 Py_INCREF(obj);
20856 return Py_BuildValue((char *)"");
20857 }
20858 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20859 PyObject *resultobj;
20860 int arg1 = (int) 0 ;
20861 wxPaletteChangedEvent *result;
20862 PyObject * obj0 = 0 ;
20863 char *kwnames[] = {
20864 (char *) "id", NULL
20865 };
20866
20867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
20868 if (obj0) {
20869 {
20870 arg1 = (int)(SWIG_As_int(obj0));
20871 if (SWIG_arg_fail(1)) SWIG_fail;
20872 }
20873 }
20874 {
20875 PyThreadState* __tstate = wxPyBeginAllowThreads();
20876 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
20877
20878 wxPyEndAllowThreads(__tstate);
20879 if (PyErr_Occurred()) SWIG_fail;
20880 }
20881 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
20882 return resultobj;
20883 fail:
20884 return NULL;
20885 }
20886
20887
20888 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20889 PyObject *resultobj;
20890 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20891 wxWindow *arg2 = (wxWindow *) 0 ;
20892 PyObject * obj0 = 0 ;
20893 PyObject * obj1 = 0 ;
20894 char *kwnames[] = {
20895 (char *) "self",(char *) "win", NULL
20896 };
20897
20898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
20899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20900 if (SWIG_arg_fail(1)) SWIG_fail;
20901 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20902 if (SWIG_arg_fail(2)) SWIG_fail;
20903 {
20904 PyThreadState* __tstate = wxPyBeginAllowThreads();
20905 (arg1)->SetChangedWindow(arg2);
20906
20907 wxPyEndAllowThreads(__tstate);
20908 if (PyErr_Occurred()) SWIG_fail;
20909 }
20910 Py_INCREF(Py_None); resultobj = Py_None;
20911 return resultobj;
20912 fail:
20913 return NULL;
20914 }
20915
20916
20917 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20918 PyObject *resultobj;
20919 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20920 wxWindow *result;
20921 PyObject * obj0 = 0 ;
20922 char *kwnames[] = {
20923 (char *) "self", NULL
20924 };
20925
20926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
20927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20928 if (SWIG_arg_fail(1)) SWIG_fail;
20929 {
20930 PyThreadState* __tstate = wxPyBeginAllowThreads();
20931 result = (wxWindow *)(arg1)->GetChangedWindow();
20932
20933 wxPyEndAllowThreads(__tstate);
20934 if (PyErr_Occurred()) SWIG_fail;
20935 }
20936 {
20937 resultobj = wxPyMake_wxObject(result, 0);
20938 }
20939 return resultobj;
20940 fail:
20941 return NULL;
20942 }
20943
20944
20945 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
20946 PyObject *obj;
20947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20948 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
20949 Py_INCREF(obj);
20950 return Py_BuildValue((char *)"");
20951 }
20952 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20953 PyObject *resultobj;
20954 int arg1 = (int) 0 ;
20955 wxQueryNewPaletteEvent *result;
20956 PyObject * obj0 = 0 ;
20957 char *kwnames[] = {
20958 (char *) "winid", NULL
20959 };
20960
20961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
20962 if (obj0) {
20963 {
20964 arg1 = (int)(SWIG_As_int(obj0));
20965 if (SWIG_arg_fail(1)) SWIG_fail;
20966 }
20967 }
20968 {
20969 PyThreadState* __tstate = wxPyBeginAllowThreads();
20970 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
20971
20972 wxPyEndAllowThreads(__tstate);
20973 if (PyErr_Occurred()) SWIG_fail;
20974 }
20975 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
20976 return resultobj;
20977 fail:
20978 return NULL;
20979 }
20980
20981
20982 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20983 PyObject *resultobj;
20984 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20985 bool arg2 ;
20986 PyObject * obj0 = 0 ;
20987 PyObject * obj1 = 0 ;
20988 char *kwnames[] = {
20989 (char *) "self",(char *) "realized", NULL
20990 };
20991
20992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
20993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
20994 if (SWIG_arg_fail(1)) SWIG_fail;
20995 {
20996 arg2 = (bool)(SWIG_As_bool(obj1));
20997 if (SWIG_arg_fail(2)) SWIG_fail;
20998 }
20999 {
21000 PyThreadState* __tstate = wxPyBeginAllowThreads();
21001 (arg1)->SetPaletteRealized(arg2);
21002
21003 wxPyEndAllowThreads(__tstate);
21004 if (PyErr_Occurred()) SWIG_fail;
21005 }
21006 Py_INCREF(Py_None); resultobj = Py_None;
21007 return resultobj;
21008 fail:
21009 return NULL;
21010 }
21011
21012
21013 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21014 PyObject *resultobj;
21015 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21016 bool result;
21017 PyObject * obj0 = 0 ;
21018 char *kwnames[] = {
21019 (char *) "self", NULL
21020 };
21021
21022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21024 if (SWIG_arg_fail(1)) SWIG_fail;
21025 {
21026 PyThreadState* __tstate = wxPyBeginAllowThreads();
21027 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21028
21029 wxPyEndAllowThreads(__tstate);
21030 if (PyErr_Occurred()) SWIG_fail;
21031 }
21032 {
21033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21034 }
21035 return resultobj;
21036 fail:
21037 return NULL;
21038 }
21039
21040
21041 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21042 PyObject *obj;
21043 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21044 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21045 Py_INCREF(obj);
21046 return Py_BuildValue((char *)"");
21047 }
21048 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21049 PyObject *resultobj;
21050 wxNavigationKeyEvent *result;
21051 char *kwnames[] = {
21052 NULL
21053 };
21054
21055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21056 {
21057 PyThreadState* __tstate = wxPyBeginAllowThreads();
21058 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21059
21060 wxPyEndAllowThreads(__tstate);
21061 if (PyErr_Occurred()) SWIG_fail;
21062 }
21063 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21064 return resultobj;
21065 fail:
21066 return NULL;
21067 }
21068
21069
21070 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21071 PyObject *resultobj;
21072 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21073 bool result;
21074 PyObject * obj0 = 0 ;
21075 char *kwnames[] = {
21076 (char *) "self", NULL
21077 };
21078
21079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21081 if (SWIG_arg_fail(1)) SWIG_fail;
21082 {
21083 PyThreadState* __tstate = wxPyBeginAllowThreads();
21084 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21085
21086 wxPyEndAllowThreads(__tstate);
21087 if (PyErr_Occurred()) SWIG_fail;
21088 }
21089 {
21090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21091 }
21092 return resultobj;
21093 fail:
21094 return NULL;
21095 }
21096
21097
21098 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21099 PyObject *resultobj;
21100 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21101 bool arg2 ;
21102 PyObject * obj0 = 0 ;
21103 PyObject * obj1 = 0 ;
21104 char *kwnames[] = {
21105 (char *) "self",(char *) "forward", NULL
21106 };
21107
21108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21110 if (SWIG_arg_fail(1)) SWIG_fail;
21111 {
21112 arg2 = (bool)(SWIG_As_bool(obj1));
21113 if (SWIG_arg_fail(2)) SWIG_fail;
21114 }
21115 {
21116 PyThreadState* __tstate = wxPyBeginAllowThreads();
21117 (arg1)->SetDirection(arg2);
21118
21119 wxPyEndAllowThreads(__tstate);
21120 if (PyErr_Occurred()) SWIG_fail;
21121 }
21122 Py_INCREF(Py_None); resultobj = Py_None;
21123 return resultobj;
21124 fail:
21125 return NULL;
21126 }
21127
21128
21129 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21130 PyObject *resultobj;
21131 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21132 bool result;
21133 PyObject * obj0 = 0 ;
21134 char *kwnames[] = {
21135 (char *) "self", NULL
21136 };
21137
21138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21140 if (SWIG_arg_fail(1)) SWIG_fail;
21141 {
21142 PyThreadState* __tstate = wxPyBeginAllowThreads();
21143 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21144
21145 wxPyEndAllowThreads(__tstate);
21146 if (PyErr_Occurred()) SWIG_fail;
21147 }
21148 {
21149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21150 }
21151 return resultobj;
21152 fail:
21153 return NULL;
21154 }
21155
21156
21157 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21158 PyObject *resultobj;
21159 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21160 bool arg2 ;
21161 PyObject * obj0 = 0 ;
21162 PyObject * obj1 = 0 ;
21163 char *kwnames[] = {
21164 (char *) "self",(char *) "ischange", NULL
21165 };
21166
21167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21169 if (SWIG_arg_fail(1)) SWIG_fail;
21170 {
21171 arg2 = (bool)(SWIG_As_bool(obj1));
21172 if (SWIG_arg_fail(2)) SWIG_fail;
21173 }
21174 {
21175 PyThreadState* __tstate = wxPyBeginAllowThreads();
21176 (arg1)->SetWindowChange(arg2);
21177
21178 wxPyEndAllowThreads(__tstate);
21179 if (PyErr_Occurred()) SWIG_fail;
21180 }
21181 Py_INCREF(Py_None); resultobj = Py_None;
21182 return resultobj;
21183 fail:
21184 return NULL;
21185 }
21186
21187
21188 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21189 PyObject *resultobj;
21190 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21191 bool result;
21192 PyObject * obj0 = 0 ;
21193 char *kwnames[] = {
21194 (char *) "self", NULL
21195 };
21196
21197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21199 if (SWIG_arg_fail(1)) SWIG_fail;
21200 {
21201 PyThreadState* __tstate = wxPyBeginAllowThreads();
21202 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21203
21204 wxPyEndAllowThreads(__tstate);
21205 if (PyErr_Occurred()) SWIG_fail;
21206 }
21207 {
21208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21209 }
21210 return resultobj;
21211 fail:
21212 return NULL;
21213 }
21214
21215
21216 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21217 PyObject *resultobj;
21218 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21219 bool arg2 ;
21220 PyObject * obj0 = 0 ;
21221 PyObject * obj1 = 0 ;
21222 char *kwnames[] = {
21223 (char *) "self",(char *) "bIs", NULL
21224 };
21225
21226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21228 if (SWIG_arg_fail(1)) SWIG_fail;
21229 {
21230 arg2 = (bool)(SWIG_As_bool(obj1));
21231 if (SWIG_arg_fail(2)) SWIG_fail;
21232 }
21233 {
21234 PyThreadState* __tstate = wxPyBeginAllowThreads();
21235 (arg1)->SetFromTab(arg2);
21236
21237 wxPyEndAllowThreads(__tstate);
21238 if (PyErr_Occurred()) SWIG_fail;
21239 }
21240 Py_INCREF(Py_None); resultobj = Py_None;
21241 return resultobj;
21242 fail:
21243 return NULL;
21244 }
21245
21246
21247 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21248 PyObject *resultobj;
21249 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21250 long arg2 ;
21251 PyObject * obj0 = 0 ;
21252 PyObject * obj1 = 0 ;
21253 char *kwnames[] = {
21254 (char *) "self",(char *) "flags", NULL
21255 };
21256
21257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21259 if (SWIG_arg_fail(1)) SWIG_fail;
21260 {
21261 arg2 = (long)(SWIG_As_long(obj1));
21262 if (SWIG_arg_fail(2)) SWIG_fail;
21263 }
21264 {
21265 PyThreadState* __tstate = wxPyBeginAllowThreads();
21266 (arg1)->SetFlags(arg2);
21267
21268 wxPyEndAllowThreads(__tstate);
21269 if (PyErr_Occurred()) SWIG_fail;
21270 }
21271 Py_INCREF(Py_None); resultobj = Py_None;
21272 return resultobj;
21273 fail:
21274 return NULL;
21275 }
21276
21277
21278 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21279 PyObject *resultobj;
21280 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21281 wxWindow *result;
21282 PyObject * obj0 = 0 ;
21283 char *kwnames[] = {
21284 (char *) "self", NULL
21285 };
21286
21287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21289 if (SWIG_arg_fail(1)) SWIG_fail;
21290 {
21291 PyThreadState* __tstate = wxPyBeginAllowThreads();
21292 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21293
21294 wxPyEndAllowThreads(__tstate);
21295 if (PyErr_Occurred()) SWIG_fail;
21296 }
21297 {
21298 resultobj = wxPyMake_wxObject(result, 0);
21299 }
21300 return resultobj;
21301 fail:
21302 return NULL;
21303 }
21304
21305
21306 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21307 PyObject *resultobj;
21308 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21309 wxWindow *arg2 = (wxWindow *) 0 ;
21310 PyObject * obj0 = 0 ;
21311 PyObject * obj1 = 0 ;
21312 char *kwnames[] = {
21313 (char *) "self",(char *) "win", NULL
21314 };
21315
21316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21318 if (SWIG_arg_fail(1)) SWIG_fail;
21319 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21320 if (SWIG_arg_fail(2)) SWIG_fail;
21321 {
21322 PyThreadState* __tstate = wxPyBeginAllowThreads();
21323 (arg1)->SetCurrentFocus(arg2);
21324
21325 wxPyEndAllowThreads(__tstate);
21326 if (PyErr_Occurred()) SWIG_fail;
21327 }
21328 Py_INCREF(Py_None); resultobj = Py_None;
21329 return resultobj;
21330 fail:
21331 return NULL;
21332 }
21333
21334
21335 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21336 PyObject *obj;
21337 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21338 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21339 Py_INCREF(obj);
21340 return Py_BuildValue((char *)"");
21341 }
21342 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21343 PyObject *resultobj;
21344 wxWindow *arg1 = (wxWindow *) NULL ;
21345 wxWindowCreateEvent *result;
21346 PyObject * obj0 = 0 ;
21347 char *kwnames[] = {
21348 (char *) "win", NULL
21349 };
21350
21351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21352 if (obj0) {
21353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21354 if (SWIG_arg_fail(1)) SWIG_fail;
21355 }
21356 {
21357 PyThreadState* __tstate = wxPyBeginAllowThreads();
21358 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21359
21360 wxPyEndAllowThreads(__tstate);
21361 if (PyErr_Occurred()) SWIG_fail;
21362 }
21363 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21364 return resultobj;
21365 fail:
21366 return NULL;
21367 }
21368
21369
21370 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21371 PyObject *resultobj;
21372 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21373 wxWindow *result;
21374 PyObject * obj0 = 0 ;
21375 char *kwnames[] = {
21376 (char *) "self", NULL
21377 };
21378
21379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21381 if (SWIG_arg_fail(1)) SWIG_fail;
21382 {
21383 PyThreadState* __tstate = wxPyBeginAllowThreads();
21384 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21385
21386 wxPyEndAllowThreads(__tstate);
21387 if (PyErr_Occurred()) SWIG_fail;
21388 }
21389 {
21390 resultobj = wxPyMake_wxObject(result, 0);
21391 }
21392 return resultobj;
21393 fail:
21394 return NULL;
21395 }
21396
21397
21398 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21399 PyObject *obj;
21400 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21401 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21402 Py_INCREF(obj);
21403 return Py_BuildValue((char *)"");
21404 }
21405 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21406 PyObject *resultobj;
21407 wxWindow *arg1 = (wxWindow *) NULL ;
21408 wxWindowDestroyEvent *result;
21409 PyObject * obj0 = 0 ;
21410 char *kwnames[] = {
21411 (char *) "win", NULL
21412 };
21413
21414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21415 if (obj0) {
21416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21417 if (SWIG_arg_fail(1)) SWIG_fail;
21418 }
21419 {
21420 PyThreadState* __tstate = wxPyBeginAllowThreads();
21421 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21422
21423 wxPyEndAllowThreads(__tstate);
21424 if (PyErr_Occurred()) SWIG_fail;
21425 }
21426 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21427 return resultobj;
21428 fail:
21429 return NULL;
21430 }
21431
21432
21433 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21434 PyObject *resultobj;
21435 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21436 wxWindow *result;
21437 PyObject * obj0 = 0 ;
21438 char *kwnames[] = {
21439 (char *) "self", NULL
21440 };
21441
21442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21444 if (SWIG_arg_fail(1)) SWIG_fail;
21445 {
21446 PyThreadState* __tstate = wxPyBeginAllowThreads();
21447 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21448
21449 wxPyEndAllowThreads(__tstate);
21450 if (PyErr_Occurred()) SWIG_fail;
21451 }
21452 {
21453 resultobj = wxPyMake_wxObject(result, 0);
21454 }
21455 return resultobj;
21456 fail:
21457 return NULL;
21458 }
21459
21460
21461 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21462 PyObject *obj;
21463 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21464 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21465 Py_INCREF(obj);
21466 return Py_BuildValue((char *)"");
21467 }
21468 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21469 PyObject *resultobj;
21470 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21471 int arg2 = (int) 0 ;
21472 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21473 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21474 wxContextMenuEvent *result;
21475 wxPoint temp3 ;
21476 PyObject * obj0 = 0 ;
21477 PyObject * obj1 = 0 ;
21478 PyObject * obj2 = 0 ;
21479 char *kwnames[] = {
21480 (char *) "type",(char *) "winid",(char *) "pt", NULL
21481 };
21482
21483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21484 if (obj0) {
21485 {
21486 arg1 = (wxEventType)(SWIG_As_int(obj0));
21487 if (SWIG_arg_fail(1)) SWIG_fail;
21488 }
21489 }
21490 if (obj1) {
21491 {
21492 arg2 = (int)(SWIG_As_int(obj1));
21493 if (SWIG_arg_fail(2)) SWIG_fail;
21494 }
21495 }
21496 if (obj2) {
21497 {
21498 arg3 = &temp3;
21499 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21500 }
21501 }
21502 {
21503 PyThreadState* __tstate = wxPyBeginAllowThreads();
21504 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21505
21506 wxPyEndAllowThreads(__tstate);
21507 if (PyErr_Occurred()) SWIG_fail;
21508 }
21509 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21510 return resultobj;
21511 fail:
21512 return NULL;
21513 }
21514
21515
21516 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21517 PyObject *resultobj;
21518 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21519 wxPoint *result;
21520 PyObject * obj0 = 0 ;
21521 char *kwnames[] = {
21522 (char *) "self", NULL
21523 };
21524
21525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21527 if (SWIG_arg_fail(1)) SWIG_fail;
21528 {
21529 PyThreadState* __tstate = wxPyBeginAllowThreads();
21530 {
21531 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21532 result = (wxPoint *) &_result_ref;
21533 }
21534
21535 wxPyEndAllowThreads(__tstate);
21536 if (PyErr_Occurred()) SWIG_fail;
21537 }
21538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21539 return resultobj;
21540 fail:
21541 return NULL;
21542 }
21543
21544
21545 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21546 PyObject *resultobj;
21547 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21548 wxPoint *arg2 = 0 ;
21549 wxPoint temp2 ;
21550 PyObject * obj0 = 0 ;
21551 PyObject * obj1 = 0 ;
21552 char *kwnames[] = {
21553 (char *) "self",(char *) "pos", NULL
21554 };
21555
21556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21558 if (SWIG_arg_fail(1)) SWIG_fail;
21559 {
21560 arg2 = &temp2;
21561 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21562 }
21563 {
21564 PyThreadState* __tstate = wxPyBeginAllowThreads();
21565 (arg1)->SetPosition((wxPoint const &)*arg2);
21566
21567 wxPyEndAllowThreads(__tstate);
21568 if (PyErr_Occurred()) SWIG_fail;
21569 }
21570 Py_INCREF(Py_None); resultobj = Py_None;
21571 return resultobj;
21572 fail:
21573 return NULL;
21574 }
21575
21576
21577 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21578 PyObject *obj;
21579 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21580 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21581 Py_INCREF(obj);
21582 return Py_BuildValue((char *)"");
21583 }
21584 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21585 PyObject *resultobj;
21586 wxIdleEvent *result;
21587 char *kwnames[] = {
21588 NULL
21589 };
21590
21591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21592 {
21593 PyThreadState* __tstate = wxPyBeginAllowThreads();
21594 result = (wxIdleEvent *)new wxIdleEvent();
21595
21596 wxPyEndAllowThreads(__tstate);
21597 if (PyErr_Occurred()) SWIG_fail;
21598 }
21599 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21600 return resultobj;
21601 fail:
21602 return NULL;
21603 }
21604
21605
21606 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21607 PyObject *resultobj;
21608 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21609 bool arg2 = (bool) true ;
21610 PyObject * obj0 = 0 ;
21611 PyObject * obj1 = 0 ;
21612 char *kwnames[] = {
21613 (char *) "self",(char *) "needMore", NULL
21614 };
21615
21616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21618 if (SWIG_arg_fail(1)) SWIG_fail;
21619 if (obj1) {
21620 {
21621 arg2 = (bool)(SWIG_As_bool(obj1));
21622 if (SWIG_arg_fail(2)) SWIG_fail;
21623 }
21624 }
21625 {
21626 PyThreadState* __tstate = wxPyBeginAllowThreads();
21627 (arg1)->RequestMore(arg2);
21628
21629 wxPyEndAllowThreads(__tstate);
21630 if (PyErr_Occurred()) SWIG_fail;
21631 }
21632 Py_INCREF(Py_None); resultobj = Py_None;
21633 return resultobj;
21634 fail:
21635 return NULL;
21636 }
21637
21638
21639 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21640 PyObject *resultobj;
21641 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21642 bool result;
21643 PyObject * obj0 = 0 ;
21644 char *kwnames[] = {
21645 (char *) "self", NULL
21646 };
21647
21648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21650 if (SWIG_arg_fail(1)) SWIG_fail;
21651 {
21652 PyThreadState* __tstate = wxPyBeginAllowThreads();
21653 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21654
21655 wxPyEndAllowThreads(__tstate);
21656 if (PyErr_Occurred()) SWIG_fail;
21657 }
21658 {
21659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21660 }
21661 return resultobj;
21662 fail:
21663 return NULL;
21664 }
21665
21666
21667 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21668 PyObject *resultobj;
21669 wxIdleMode arg1 ;
21670 PyObject * obj0 = 0 ;
21671 char *kwnames[] = {
21672 (char *) "mode", NULL
21673 };
21674
21675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21676 {
21677 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21678 if (SWIG_arg_fail(1)) SWIG_fail;
21679 }
21680 {
21681 PyThreadState* __tstate = wxPyBeginAllowThreads();
21682 wxIdleEvent::SetMode((wxIdleMode )arg1);
21683
21684 wxPyEndAllowThreads(__tstate);
21685 if (PyErr_Occurred()) SWIG_fail;
21686 }
21687 Py_INCREF(Py_None); resultobj = Py_None;
21688 return resultobj;
21689 fail:
21690 return NULL;
21691 }
21692
21693
21694 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21695 PyObject *resultobj;
21696 wxIdleMode result;
21697 char *kwnames[] = {
21698 NULL
21699 };
21700
21701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21702 {
21703 PyThreadState* __tstate = wxPyBeginAllowThreads();
21704 result = (wxIdleMode)wxIdleEvent::GetMode();
21705
21706 wxPyEndAllowThreads(__tstate);
21707 if (PyErr_Occurred()) SWIG_fail;
21708 }
21709 resultobj = SWIG_From_int((result));
21710 return resultobj;
21711 fail:
21712 return NULL;
21713 }
21714
21715
21716 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
21717 PyObject *resultobj;
21718 wxWindow *arg1 = (wxWindow *) 0 ;
21719 bool result;
21720 PyObject * obj0 = 0 ;
21721 char *kwnames[] = {
21722 (char *) "win", NULL
21723 };
21724
21725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
21726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21727 if (SWIG_arg_fail(1)) SWIG_fail;
21728 {
21729 PyThreadState* __tstate = wxPyBeginAllowThreads();
21730 result = (bool)wxIdleEvent::CanSend(arg1);
21731
21732 wxPyEndAllowThreads(__tstate);
21733 if (PyErr_Occurred()) SWIG_fail;
21734 }
21735 {
21736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21737 }
21738 return resultobj;
21739 fail:
21740 return NULL;
21741 }
21742
21743
21744 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
21745 PyObject *obj;
21746 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21747 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
21748 Py_INCREF(obj);
21749 return Py_BuildValue((char *)"");
21750 }
21751 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21752 PyObject *resultobj;
21753 int arg1 = (int) 0 ;
21754 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
21755 wxPyEvent *result;
21756 PyObject * obj0 = 0 ;
21757 PyObject * obj1 = 0 ;
21758 char *kwnames[] = {
21759 (char *) "winid",(char *) "commandType", NULL
21760 };
21761
21762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
21763 if (obj0) {
21764 {
21765 arg1 = (int)(SWIG_As_int(obj0));
21766 if (SWIG_arg_fail(1)) SWIG_fail;
21767 }
21768 }
21769 if (obj1) {
21770 {
21771 arg2 = (wxEventType)(SWIG_As_int(obj1));
21772 if (SWIG_arg_fail(2)) SWIG_fail;
21773 }
21774 }
21775 {
21776 PyThreadState* __tstate = wxPyBeginAllowThreads();
21777 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
21778
21779 wxPyEndAllowThreads(__tstate);
21780 if (PyErr_Occurred()) SWIG_fail;
21781 }
21782 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
21783 return resultobj;
21784 fail:
21785 return NULL;
21786 }
21787
21788
21789 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21790 PyObject *resultobj;
21791 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21792 PyObject * obj0 = 0 ;
21793 char *kwnames[] = {
21794 (char *) "self", NULL
21795 };
21796
21797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
21798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21799 if (SWIG_arg_fail(1)) SWIG_fail;
21800 {
21801 PyThreadState* __tstate = wxPyBeginAllowThreads();
21802 delete arg1;
21803
21804 wxPyEndAllowThreads(__tstate);
21805 if (PyErr_Occurred()) SWIG_fail;
21806 }
21807 Py_INCREF(Py_None); resultobj = Py_None;
21808 return resultobj;
21809 fail:
21810 return NULL;
21811 }
21812
21813
21814 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21815 PyObject *resultobj;
21816 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21817 PyObject *arg2 = (PyObject *) 0 ;
21818 PyObject * obj0 = 0 ;
21819 PyObject * obj1 = 0 ;
21820 char *kwnames[] = {
21821 (char *) "self",(char *) "self", NULL
21822 };
21823
21824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21826 if (SWIG_arg_fail(1)) SWIG_fail;
21827 arg2 = obj1;
21828 {
21829 PyThreadState* __tstate = wxPyBeginAllowThreads();
21830 (arg1)->SetSelf(arg2);
21831
21832 wxPyEndAllowThreads(__tstate);
21833 if (PyErr_Occurred()) SWIG_fail;
21834 }
21835 Py_INCREF(Py_None); resultobj = Py_None;
21836 return resultobj;
21837 fail:
21838 return NULL;
21839 }
21840
21841
21842 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21843 PyObject *resultobj;
21844 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21845 PyObject *result;
21846 PyObject * obj0 = 0 ;
21847 char *kwnames[] = {
21848 (char *) "self", NULL
21849 };
21850
21851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
21852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21853 if (SWIG_arg_fail(1)) SWIG_fail;
21854 {
21855 PyThreadState* __tstate = wxPyBeginAllowThreads();
21856 result = (PyObject *)(arg1)->GetSelf();
21857
21858 wxPyEndAllowThreads(__tstate);
21859 if (PyErr_Occurred()) SWIG_fail;
21860 }
21861 resultobj = result;
21862 return resultobj;
21863 fail:
21864 return NULL;
21865 }
21866
21867
21868 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
21869 PyObject *obj;
21870 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21871 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
21872 Py_INCREF(obj);
21873 return Py_BuildValue((char *)"");
21874 }
21875 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21876 PyObject *resultobj;
21877 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21878 int arg2 = (int) 0 ;
21879 wxPyCommandEvent *result;
21880 PyObject * obj0 = 0 ;
21881 PyObject * obj1 = 0 ;
21882 char *kwnames[] = {
21883 (char *) "commandType",(char *) "id", NULL
21884 };
21885
21886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
21887 if (obj0) {
21888 {
21889 arg1 = (wxEventType)(SWIG_As_int(obj0));
21890 if (SWIG_arg_fail(1)) SWIG_fail;
21891 }
21892 }
21893 if (obj1) {
21894 {
21895 arg2 = (int)(SWIG_As_int(obj1));
21896 if (SWIG_arg_fail(2)) SWIG_fail;
21897 }
21898 }
21899 {
21900 PyThreadState* __tstate = wxPyBeginAllowThreads();
21901 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
21902
21903 wxPyEndAllowThreads(__tstate);
21904 if (PyErr_Occurred()) SWIG_fail;
21905 }
21906 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
21907 return resultobj;
21908 fail:
21909 return NULL;
21910 }
21911
21912
21913 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21914 PyObject *resultobj;
21915 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21916 PyObject * obj0 = 0 ;
21917 char *kwnames[] = {
21918 (char *) "self", NULL
21919 };
21920
21921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
21922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21923 if (SWIG_arg_fail(1)) SWIG_fail;
21924 {
21925 PyThreadState* __tstate = wxPyBeginAllowThreads();
21926 delete arg1;
21927
21928 wxPyEndAllowThreads(__tstate);
21929 if (PyErr_Occurred()) SWIG_fail;
21930 }
21931 Py_INCREF(Py_None); resultobj = Py_None;
21932 return resultobj;
21933 fail:
21934 return NULL;
21935 }
21936
21937
21938 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21939 PyObject *resultobj;
21940 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21941 PyObject *arg2 = (PyObject *) 0 ;
21942 PyObject * obj0 = 0 ;
21943 PyObject * obj1 = 0 ;
21944 char *kwnames[] = {
21945 (char *) "self",(char *) "self", NULL
21946 };
21947
21948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21950 if (SWIG_arg_fail(1)) SWIG_fail;
21951 arg2 = obj1;
21952 {
21953 PyThreadState* __tstate = wxPyBeginAllowThreads();
21954 (arg1)->SetSelf(arg2);
21955
21956 wxPyEndAllowThreads(__tstate);
21957 if (PyErr_Occurred()) SWIG_fail;
21958 }
21959 Py_INCREF(Py_None); resultobj = Py_None;
21960 return resultobj;
21961 fail:
21962 return NULL;
21963 }
21964
21965
21966 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21967 PyObject *resultobj;
21968 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21969 PyObject *result;
21970 PyObject * obj0 = 0 ;
21971 char *kwnames[] = {
21972 (char *) "self", NULL
21973 };
21974
21975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
21976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21977 if (SWIG_arg_fail(1)) SWIG_fail;
21978 {
21979 PyThreadState* __tstate = wxPyBeginAllowThreads();
21980 result = (PyObject *)(arg1)->GetSelf();
21981
21982 wxPyEndAllowThreads(__tstate);
21983 if (PyErr_Occurred()) SWIG_fail;
21984 }
21985 resultobj = result;
21986 return resultobj;
21987 fail:
21988 return NULL;
21989 }
21990
21991
21992 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
21993 PyObject *obj;
21994 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21995 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
21996 Py_INCREF(obj);
21997 return Py_BuildValue((char *)"");
21998 }
21999 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22000 PyObject *resultobj;
22001 wxWindow *arg1 = (wxWindow *) 0 ;
22002 wxDateTime *arg2 = 0 ;
22003 wxEventType arg3 ;
22004 wxDateEvent *result;
22005 PyObject * obj0 = 0 ;
22006 PyObject * obj1 = 0 ;
22007 PyObject * obj2 = 0 ;
22008 char *kwnames[] = {
22009 (char *) "win",(char *) "dt",(char *) "type", NULL
22010 };
22011
22012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22014 if (SWIG_arg_fail(1)) SWIG_fail;
22015 {
22016 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22017 if (SWIG_arg_fail(2)) SWIG_fail;
22018 if (arg2 == NULL) {
22019 SWIG_null_ref("wxDateTime");
22020 }
22021 if (SWIG_arg_fail(2)) SWIG_fail;
22022 }
22023 {
22024 arg3 = (wxEventType)(SWIG_As_int(obj2));
22025 if (SWIG_arg_fail(3)) SWIG_fail;
22026 }
22027 {
22028 PyThreadState* __tstate = wxPyBeginAllowThreads();
22029 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22030
22031 wxPyEndAllowThreads(__tstate);
22032 if (PyErr_Occurred()) SWIG_fail;
22033 }
22034 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22035 return resultobj;
22036 fail:
22037 return NULL;
22038 }
22039
22040
22041 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22042 PyObject *resultobj;
22043 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22044 wxDateTime *result;
22045 PyObject * obj0 = 0 ;
22046 char *kwnames[] = {
22047 (char *) "self", NULL
22048 };
22049
22050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22052 if (SWIG_arg_fail(1)) SWIG_fail;
22053 {
22054 PyThreadState* __tstate = wxPyBeginAllowThreads();
22055 {
22056 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22057 result = (wxDateTime *) &_result_ref;
22058 }
22059
22060 wxPyEndAllowThreads(__tstate);
22061 if (PyErr_Occurred()) SWIG_fail;
22062 }
22063 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22064 return resultobj;
22065 fail:
22066 return NULL;
22067 }
22068
22069
22070 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22071 PyObject *resultobj;
22072 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22073 wxDateTime *arg2 = 0 ;
22074 PyObject * obj0 = 0 ;
22075 PyObject * obj1 = 0 ;
22076 char *kwnames[] = {
22077 (char *) "self",(char *) "date", NULL
22078 };
22079
22080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22082 if (SWIG_arg_fail(1)) SWIG_fail;
22083 {
22084 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22085 if (SWIG_arg_fail(2)) SWIG_fail;
22086 if (arg2 == NULL) {
22087 SWIG_null_ref("wxDateTime");
22088 }
22089 if (SWIG_arg_fail(2)) SWIG_fail;
22090 }
22091 {
22092 PyThreadState* __tstate = wxPyBeginAllowThreads();
22093 (arg1)->SetDate((wxDateTime const &)*arg2);
22094
22095 wxPyEndAllowThreads(__tstate);
22096 if (PyErr_Occurred()) SWIG_fail;
22097 }
22098 Py_INCREF(Py_None); resultobj = Py_None;
22099 return resultobj;
22100 fail:
22101 return NULL;
22102 }
22103
22104
22105 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22106 PyObject *obj;
22107 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22108 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22109 Py_INCREF(obj);
22110 return Py_BuildValue((char *)"");
22111 }
22112 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22113 PyObject *resultobj;
22114 wxPyApp *result;
22115 char *kwnames[] = {
22116 NULL
22117 };
22118
22119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22120 {
22121 PyThreadState* __tstate = wxPyBeginAllowThreads();
22122 result = (wxPyApp *)new_wxPyApp();
22123
22124 wxPyEndAllowThreads(__tstate);
22125 if (PyErr_Occurred()) SWIG_fail;
22126 }
22127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22128 return resultobj;
22129 fail:
22130 return NULL;
22131 }
22132
22133
22134 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22135 PyObject *resultobj;
22136 wxPyApp *arg1 = (wxPyApp *) 0 ;
22137 PyObject * obj0 = 0 ;
22138 char *kwnames[] = {
22139 (char *) "self", NULL
22140 };
22141
22142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22144 if (SWIG_arg_fail(1)) SWIG_fail;
22145 {
22146 PyThreadState* __tstate = wxPyBeginAllowThreads();
22147 delete arg1;
22148
22149 wxPyEndAllowThreads(__tstate);
22150 if (PyErr_Occurred()) SWIG_fail;
22151 }
22152 Py_INCREF(Py_None); resultobj = Py_None;
22153 return resultobj;
22154 fail:
22155 return NULL;
22156 }
22157
22158
22159 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22160 PyObject *resultobj;
22161 wxPyApp *arg1 = (wxPyApp *) 0 ;
22162 PyObject *arg2 = (PyObject *) 0 ;
22163 PyObject *arg3 = (PyObject *) 0 ;
22164 PyObject * obj0 = 0 ;
22165 PyObject * obj1 = 0 ;
22166 PyObject * obj2 = 0 ;
22167 char *kwnames[] = {
22168 (char *) "self",(char *) "self",(char *) "_class", NULL
22169 };
22170
22171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22173 if (SWIG_arg_fail(1)) SWIG_fail;
22174 arg2 = obj1;
22175 arg3 = obj2;
22176 {
22177 PyThreadState* __tstate = wxPyBeginAllowThreads();
22178 (arg1)->_setCallbackInfo(arg2,arg3);
22179
22180 wxPyEndAllowThreads(__tstate);
22181 if (PyErr_Occurred()) SWIG_fail;
22182 }
22183 Py_INCREF(Py_None); resultobj = Py_None;
22184 return resultobj;
22185 fail:
22186 return NULL;
22187 }
22188
22189
22190 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22191 PyObject *resultobj;
22192 wxPyApp *arg1 = (wxPyApp *) 0 ;
22193 wxString result;
22194 PyObject * obj0 = 0 ;
22195 char *kwnames[] = {
22196 (char *) "self", NULL
22197 };
22198
22199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22201 if (SWIG_arg_fail(1)) SWIG_fail;
22202 {
22203 PyThreadState* __tstate = wxPyBeginAllowThreads();
22204 result = ((wxPyApp const *)arg1)->GetAppName();
22205
22206 wxPyEndAllowThreads(__tstate);
22207 if (PyErr_Occurred()) SWIG_fail;
22208 }
22209 {
22210 #if wxUSE_UNICODE
22211 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22212 #else
22213 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22214 #endif
22215 }
22216 return resultobj;
22217 fail:
22218 return NULL;
22219 }
22220
22221
22222 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22223 PyObject *resultobj;
22224 wxPyApp *arg1 = (wxPyApp *) 0 ;
22225 wxString *arg2 = 0 ;
22226 bool temp2 = false ;
22227 PyObject * obj0 = 0 ;
22228 PyObject * obj1 = 0 ;
22229 char *kwnames[] = {
22230 (char *) "self",(char *) "name", NULL
22231 };
22232
22233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22235 if (SWIG_arg_fail(1)) SWIG_fail;
22236 {
22237 arg2 = wxString_in_helper(obj1);
22238 if (arg2 == NULL) SWIG_fail;
22239 temp2 = true;
22240 }
22241 {
22242 PyThreadState* __tstate = wxPyBeginAllowThreads();
22243 (arg1)->SetAppName((wxString const &)*arg2);
22244
22245 wxPyEndAllowThreads(__tstate);
22246 if (PyErr_Occurred()) SWIG_fail;
22247 }
22248 Py_INCREF(Py_None); resultobj = Py_None;
22249 {
22250 if (temp2)
22251 delete arg2;
22252 }
22253 return resultobj;
22254 fail:
22255 {
22256 if (temp2)
22257 delete arg2;
22258 }
22259 return NULL;
22260 }
22261
22262
22263 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22264 PyObject *resultobj;
22265 wxPyApp *arg1 = (wxPyApp *) 0 ;
22266 wxString result;
22267 PyObject * obj0 = 0 ;
22268 char *kwnames[] = {
22269 (char *) "self", NULL
22270 };
22271
22272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22274 if (SWIG_arg_fail(1)) SWIG_fail;
22275 {
22276 PyThreadState* __tstate = wxPyBeginAllowThreads();
22277 result = ((wxPyApp const *)arg1)->GetClassName();
22278
22279 wxPyEndAllowThreads(__tstate);
22280 if (PyErr_Occurred()) SWIG_fail;
22281 }
22282 {
22283 #if wxUSE_UNICODE
22284 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22285 #else
22286 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22287 #endif
22288 }
22289 return resultobj;
22290 fail:
22291 return NULL;
22292 }
22293
22294
22295 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22296 PyObject *resultobj;
22297 wxPyApp *arg1 = (wxPyApp *) 0 ;
22298 wxString *arg2 = 0 ;
22299 bool temp2 = false ;
22300 PyObject * obj0 = 0 ;
22301 PyObject * obj1 = 0 ;
22302 char *kwnames[] = {
22303 (char *) "self",(char *) "name", NULL
22304 };
22305
22306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22308 if (SWIG_arg_fail(1)) SWIG_fail;
22309 {
22310 arg2 = wxString_in_helper(obj1);
22311 if (arg2 == NULL) SWIG_fail;
22312 temp2 = true;
22313 }
22314 {
22315 PyThreadState* __tstate = wxPyBeginAllowThreads();
22316 (arg1)->SetClassName((wxString const &)*arg2);
22317
22318 wxPyEndAllowThreads(__tstate);
22319 if (PyErr_Occurred()) SWIG_fail;
22320 }
22321 Py_INCREF(Py_None); resultobj = Py_None;
22322 {
22323 if (temp2)
22324 delete arg2;
22325 }
22326 return resultobj;
22327 fail:
22328 {
22329 if (temp2)
22330 delete arg2;
22331 }
22332 return NULL;
22333 }
22334
22335
22336 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22337 PyObject *resultobj;
22338 wxPyApp *arg1 = (wxPyApp *) 0 ;
22339 wxString *result;
22340 PyObject * obj0 = 0 ;
22341 char *kwnames[] = {
22342 (char *) "self", NULL
22343 };
22344
22345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22347 if (SWIG_arg_fail(1)) SWIG_fail;
22348 {
22349 PyThreadState* __tstate = wxPyBeginAllowThreads();
22350 {
22351 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22352 result = (wxString *) &_result_ref;
22353 }
22354
22355 wxPyEndAllowThreads(__tstate);
22356 if (PyErr_Occurred()) SWIG_fail;
22357 }
22358 {
22359 #if wxUSE_UNICODE
22360 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22361 #else
22362 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22363 #endif
22364 }
22365 return resultobj;
22366 fail:
22367 return NULL;
22368 }
22369
22370
22371 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22372 PyObject *resultobj;
22373 wxPyApp *arg1 = (wxPyApp *) 0 ;
22374 wxString *arg2 = 0 ;
22375 bool temp2 = false ;
22376 PyObject * obj0 = 0 ;
22377 PyObject * obj1 = 0 ;
22378 char *kwnames[] = {
22379 (char *) "self",(char *) "name", NULL
22380 };
22381
22382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22384 if (SWIG_arg_fail(1)) SWIG_fail;
22385 {
22386 arg2 = wxString_in_helper(obj1);
22387 if (arg2 == NULL) SWIG_fail;
22388 temp2 = true;
22389 }
22390 {
22391 PyThreadState* __tstate = wxPyBeginAllowThreads();
22392 (arg1)->SetVendorName((wxString const &)*arg2);
22393
22394 wxPyEndAllowThreads(__tstate);
22395 if (PyErr_Occurred()) SWIG_fail;
22396 }
22397 Py_INCREF(Py_None); resultobj = Py_None;
22398 {
22399 if (temp2)
22400 delete arg2;
22401 }
22402 return resultobj;
22403 fail:
22404 {
22405 if (temp2)
22406 delete arg2;
22407 }
22408 return NULL;
22409 }
22410
22411
22412 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22413 PyObject *resultobj;
22414 wxPyApp *arg1 = (wxPyApp *) 0 ;
22415 wxAppTraits *result;
22416 PyObject * obj0 = 0 ;
22417 char *kwnames[] = {
22418 (char *) "self", NULL
22419 };
22420
22421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22423 if (SWIG_arg_fail(1)) SWIG_fail;
22424 {
22425 PyThreadState* __tstate = wxPyBeginAllowThreads();
22426 result = (wxAppTraits *)(arg1)->GetTraits();
22427
22428 wxPyEndAllowThreads(__tstate);
22429 if (PyErr_Occurred()) SWIG_fail;
22430 }
22431 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22432 return resultobj;
22433 fail:
22434 return NULL;
22435 }
22436
22437
22438 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22439 PyObject *resultobj;
22440 wxPyApp *arg1 = (wxPyApp *) 0 ;
22441 PyObject * obj0 = 0 ;
22442 char *kwnames[] = {
22443 (char *) "self", NULL
22444 };
22445
22446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22448 if (SWIG_arg_fail(1)) SWIG_fail;
22449 {
22450 PyThreadState* __tstate = wxPyBeginAllowThreads();
22451 (arg1)->ProcessPendingEvents();
22452
22453 wxPyEndAllowThreads(__tstate);
22454 if (PyErr_Occurred()) SWIG_fail;
22455 }
22456 Py_INCREF(Py_None); resultobj = Py_None;
22457 return resultobj;
22458 fail:
22459 return NULL;
22460 }
22461
22462
22463 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22464 PyObject *resultobj;
22465 wxPyApp *arg1 = (wxPyApp *) 0 ;
22466 bool arg2 = (bool) false ;
22467 bool result;
22468 PyObject * obj0 = 0 ;
22469 PyObject * obj1 = 0 ;
22470 char *kwnames[] = {
22471 (char *) "self",(char *) "onlyIfNeeded", NULL
22472 };
22473
22474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22476 if (SWIG_arg_fail(1)) SWIG_fail;
22477 if (obj1) {
22478 {
22479 arg2 = (bool)(SWIG_As_bool(obj1));
22480 if (SWIG_arg_fail(2)) SWIG_fail;
22481 }
22482 }
22483 {
22484 PyThreadState* __tstate = wxPyBeginAllowThreads();
22485 result = (bool)(arg1)->Yield(arg2);
22486
22487 wxPyEndAllowThreads(__tstate);
22488 if (PyErr_Occurred()) SWIG_fail;
22489 }
22490 {
22491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22492 }
22493 return resultobj;
22494 fail:
22495 return NULL;
22496 }
22497
22498
22499 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22500 PyObject *resultobj;
22501 wxPyApp *arg1 = (wxPyApp *) 0 ;
22502 PyObject * obj0 = 0 ;
22503 char *kwnames[] = {
22504 (char *) "self", NULL
22505 };
22506
22507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22509 if (SWIG_arg_fail(1)) SWIG_fail;
22510 {
22511 PyThreadState* __tstate = wxPyBeginAllowThreads();
22512 (arg1)->WakeUpIdle();
22513
22514 wxPyEndAllowThreads(__tstate);
22515 if (PyErr_Occurred()) SWIG_fail;
22516 }
22517 Py_INCREF(Py_None); resultobj = Py_None;
22518 return resultobj;
22519 fail:
22520 return NULL;
22521 }
22522
22523
22524 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22525 PyObject *resultobj;
22526 bool result;
22527 char *kwnames[] = {
22528 NULL
22529 };
22530
22531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22532 {
22533 PyThreadState* __tstate = wxPyBeginAllowThreads();
22534 result = (bool)wxPyApp::IsMainLoopRunning();
22535
22536 wxPyEndAllowThreads(__tstate);
22537 if (PyErr_Occurred()) SWIG_fail;
22538 }
22539 {
22540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22541 }
22542 return resultobj;
22543 fail:
22544 return NULL;
22545 }
22546
22547
22548 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22549 PyObject *resultobj;
22550 wxPyApp *arg1 = (wxPyApp *) 0 ;
22551 int result;
22552 PyObject * obj0 = 0 ;
22553 char *kwnames[] = {
22554 (char *) "self", NULL
22555 };
22556
22557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22559 if (SWIG_arg_fail(1)) SWIG_fail;
22560 {
22561 PyThreadState* __tstate = wxPyBeginAllowThreads();
22562 result = (int)(arg1)->MainLoop();
22563
22564 wxPyEndAllowThreads(__tstate);
22565 if (PyErr_Occurred()) SWIG_fail;
22566 }
22567 {
22568 resultobj = SWIG_From_int((int)(result));
22569 }
22570 return resultobj;
22571 fail:
22572 return NULL;
22573 }
22574
22575
22576 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22577 PyObject *resultobj;
22578 wxPyApp *arg1 = (wxPyApp *) 0 ;
22579 PyObject * obj0 = 0 ;
22580 char *kwnames[] = {
22581 (char *) "self", NULL
22582 };
22583
22584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22586 if (SWIG_arg_fail(1)) SWIG_fail;
22587 {
22588 PyThreadState* __tstate = wxPyBeginAllowThreads();
22589 (arg1)->Exit();
22590
22591 wxPyEndAllowThreads(__tstate);
22592 if (PyErr_Occurred()) SWIG_fail;
22593 }
22594 Py_INCREF(Py_None); resultobj = Py_None;
22595 return resultobj;
22596 fail:
22597 return NULL;
22598 }
22599
22600
22601 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22602 PyObject *resultobj;
22603 wxPyApp *arg1 = (wxPyApp *) 0 ;
22604 PyObject * obj0 = 0 ;
22605 char *kwnames[] = {
22606 (char *) "self", NULL
22607 };
22608
22609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22611 if (SWIG_arg_fail(1)) SWIG_fail;
22612 {
22613 PyThreadState* __tstate = wxPyBeginAllowThreads();
22614 (arg1)->ExitMainLoop();
22615
22616 wxPyEndAllowThreads(__tstate);
22617 if (PyErr_Occurred()) SWIG_fail;
22618 }
22619 Py_INCREF(Py_None); resultobj = Py_None;
22620 return resultobj;
22621 fail:
22622 return NULL;
22623 }
22624
22625
22626 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22627 PyObject *resultobj;
22628 wxPyApp *arg1 = (wxPyApp *) 0 ;
22629 bool result;
22630 PyObject * obj0 = 0 ;
22631 char *kwnames[] = {
22632 (char *) "self", NULL
22633 };
22634
22635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22637 if (SWIG_arg_fail(1)) SWIG_fail;
22638 {
22639 PyThreadState* __tstate = wxPyBeginAllowThreads();
22640 result = (bool)(arg1)->Pending();
22641
22642 wxPyEndAllowThreads(__tstate);
22643 if (PyErr_Occurred()) SWIG_fail;
22644 }
22645 {
22646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22647 }
22648 return resultobj;
22649 fail:
22650 return NULL;
22651 }
22652
22653
22654 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22655 PyObject *resultobj;
22656 wxPyApp *arg1 = (wxPyApp *) 0 ;
22657 bool result;
22658 PyObject * obj0 = 0 ;
22659 char *kwnames[] = {
22660 (char *) "self", NULL
22661 };
22662
22663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22665 if (SWIG_arg_fail(1)) SWIG_fail;
22666 {
22667 PyThreadState* __tstate = wxPyBeginAllowThreads();
22668 result = (bool)(arg1)->Dispatch();
22669
22670 wxPyEndAllowThreads(__tstate);
22671 if (PyErr_Occurred()) SWIG_fail;
22672 }
22673 {
22674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22675 }
22676 return resultobj;
22677 fail:
22678 return NULL;
22679 }
22680
22681
22682 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22683 PyObject *resultobj;
22684 wxPyApp *arg1 = (wxPyApp *) 0 ;
22685 bool result;
22686 PyObject * obj0 = 0 ;
22687 char *kwnames[] = {
22688 (char *) "self", NULL
22689 };
22690
22691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22693 if (SWIG_arg_fail(1)) SWIG_fail;
22694 {
22695 PyThreadState* __tstate = wxPyBeginAllowThreads();
22696 result = (bool)(arg1)->ProcessIdle();
22697
22698 wxPyEndAllowThreads(__tstate);
22699 if (PyErr_Occurred()) SWIG_fail;
22700 }
22701 {
22702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22703 }
22704 return resultobj;
22705 fail:
22706 return NULL;
22707 }
22708
22709
22710 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22711 PyObject *resultobj;
22712 wxPyApp *arg1 = (wxPyApp *) 0 ;
22713 wxWindow *arg2 = (wxWindow *) 0 ;
22714 wxIdleEvent *arg3 = 0 ;
22715 bool result;
22716 PyObject * obj0 = 0 ;
22717 PyObject * obj1 = 0 ;
22718 PyObject * obj2 = 0 ;
22719 char *kwnames[] = {
22720 (char *) "self",(char *) "win",(char *) "event", NULL
22721 };
22722
22723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
22724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22725 if (SWIG_arg_fail(1)) SWIG_fail;
22726 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22727 if (SWIG_arg_fail(2)) SWIG_fail;
22728 {
22729 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22730 if (SWIG_arg_fail(3)) SWIG_fail;
22731 if (arg3 == NULL) {
22732 SWIG_null_ref("wxIdleEvent");
22733 }
22734 if (SWIG_arg_fail(3)) SWIG_fail;
22735 }
22736 {
22737 PyThreadState* __tstate = wxPyBeginAllowThreads();
22738 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
22739
22740 wxPyEndAllowThreads(__tstate);
22741 if (PyErr_Occurred()) SWIG_fail;
22742 }
22743 {
22744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22745 }
22746 return resultobj;
22747 fail:
22748 return NULL;
22749 }
22750
22751
22752 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
22753 PyObject *resultobj;
22754 wxPyApp *arg1 = (wxPyApp *) 0 ;
22755 bool result;
22756 PyObject * obj0 = 0 ;
22757 char *kwnames[] = {
22758 (char *) "self", NULL
22759 };
22760
22761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
22762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22763 if (SWIG_arg_fail(1)) SWIG_fail;
22764 {
22765 PyThreadState* __tstate = wxPyBeginAllowThreads();
22766 result = (bool)((wxPyApp const *)arg1)->IsActive();
22767
22768 wxPyEndAllowThreads(__tstate);
22769 if (PyErr_Occurred()) SWIG_fail;
22770 }
22771 {
22772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22773 }
22774 return resultobj;
22775 fail:
22776 return NULL;
22777 }
22778
22779
22780 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22781 PyObject *resultobj;
22782 wxPyApp *arg1 = (wxPyApp *) 0 ;
22783 wxWindow *arg2 = (wxWindow *) 0 ;
22784 PyObject * obj0 = 0 ;
22785 PyObject * obj1 = 0 ;
22786 char *kwnames[] = {
22787 (char *) "self",(char *) "win", NULL
22788 };
22789
22790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
22791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22792 if (SWIG_arg_fail(1)) SWIG_fail;
22793 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22794 if (SWIG_arg_fail(2)) SWIG_fail;
22795 {
22796 PyThreadState* __tstate = wxPyBeginAllowThreads();
22797 (arg1)->SetTopWindow(arg2);
22798
22799 wxPyEndAllowThreads(__tstate);
22800 if (PyErr_Occurred()) SWIG_fail;
22801 }
22802 Py_INCREF(Py_None); resultobj = Py_None;
22803 return resultobj;
22804 fail:
22805 return NULL;
22806 }
22807
22808
22809 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22810 PyObject *resultobj;
22811 wxPyApp *arg1 = (wxPyApp *) 0 ;
22812 wxWindow *result;
22813 PyObject * obj0 = 0 ;
22814 char *kwnames[] = {
22815 (char *) "self", NULL
22816 };
22817
22818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
22819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22820 if (SWIG_arg_fail(1)) SWIG_fail;
22821 {
22822 PyThreadState* __tstate = wxPyBeginAllowThreads();
22823 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
22824
22825 wxPyEndAllowThreads(__tstate);
22826 if (PyErr_Occurred()) SWIG_fail;
22827 }
22828 {
22829 resultobj = wxPyMake_wxObject(result, 0);
22830 }
22831 return resultobj;
22832 fail:
22833 return NULL;
22834 }
22835
22836
22837 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22838 PyObject *resultobj;
22839 wxPyApp *arg1 = (wxPyApp *) 0 ;
22840 bool arg2 ;
22841 PyObject * obj0 = 0 ;
22842 PyObject * obj1 = 0 ;
22843 char *kwnames[] = {
22844 (char *) "self",(char *) "flag", NULL
22845 };
22846
22847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
22848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22849 if (SWIG_arg_fail(1)) SWIG_fail;
22850 {
22851 arg2 = (bool)(SWIG_As_bool(obj1));
22852 if (SWIG_arg_fail(2)) SWIG_fail;
22853 }
22854 {
22855 PyThreadState* __tstate = wxPyBeginAllowThreads();
22856 (arg1)->SetExitOnFrameDelete(arg2);
22857
22858 wxPyEndAllowThreads(__tstate);
22859 if (PyErr_Occurred()) SWIG_fail;
22860 }
22861 Py_INCREF(Py_None); resultobj = Py_None;
22862 return resultobj;
22863 fail:
22864 return NULL;
22865 }
22866
22867
22868 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22869 PyObject *resultobj;
22870 wxPyApp *arg1 = (wxPyApp *) 0 ;
22871 bool result;
22872 PyObject * obj0 = 0 ;
22873 char *kwnames[] = {
22874 (char *) "self", NULL
22875 };
22876
22877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
22878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22879 if (SWIG_arg_fail(1)) SWIG_fail;
22880 {
22881 PyThreadState* __tstate = wxPyBeginAllowThreads();
22882 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
22883
22884 wxPyEndAllowThreads(__tstate);
22885 if (PyErr_Occurred()) SWIG_fail;
22886 }
22887 {
22888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22889 }
22890 return resultobj;
22891 fail:
22892 return NULL;
22893 }
22894
22895
22896 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22897 PyObject *resultobj;
22898 wxPyApp *arg1 = (wxPyApp *) 0 ;
22899 bool arg2 ;
22900 PyObject * obj0 = 0 ;
22901 PyObject * obj1 = 0 ;
22902 char *kwnames[] = {
22903 (char *) "self",(char *) "flag", NULL
22904 };
22905
22906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
22907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22908 if (SWIG_arg_fail(1)) SWIG_fail;
22909 {
22910 arg2 = (bool)(SWIG_As_bool(obj1));
22911 if (SWIG_arg_fail(2)) SWIG_fail;
22912 }
22913 {
22914 PyThreadState* __tstate = wxPyBeginAllowThreads();
22915 (arg1)->SetUseBestVisual(arg2);
22916
22917 wxPyEndAllowThreads(__tstate);
22918 if (PyErr_Occurred()) SWIG_fail;
22919 }
22920 Py_INCREF(Py_None); resultobj = Py_None;
22921 return resultobj;
22922 fail:
22923 return NULL;
22924 }
22925
22926
22927 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22928 PyObject *resultobj;
22929 wxPyApp *arg1 = (wxPyApp *) 0 ;
22930 bool result;
22931 PyObject * obj0 = 0 ;
22932 char *kwnames[] = {
22933 (char *) "self", NULL
22934 };
22935
22936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
22937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22938 if (SWIG_arg_fail(1)) SWIG_fail;
22939 {
22940 PyThreadState* __tstate = wxPyBeginAllowThreads();
22941 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
22942
22943 wxPyEndAllowThreads(__tstate);
22944 if (PyErr_Occurred()) SWIG_fail;
22945 }
22946 {
22947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22948 }
22949 return resultobj;
22950 fail:
22951 return NULL;
22952 }
22953
22954
22955 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22956 PyObject *resultobj;
22957 wxPyApp *arg1 = (wxPyApp *) 0 ;
22958 int arg2 ;
22959 PyObject * obj0 = 0 ;
22960 PyObject * obj1 = 0 ;
22961 char *kwnames[] = {
22962 (char *) "self",(char *) "mode", NULL
22963 };
22964
22965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
22966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22967 if (SWIG_arg_fail(1)) SWIG_fail;
22968 {
22969 arg2 = (int)(SWIG_As_int(obj1));
22970 if (SWIG_arg_fail(2)) SWIG_fail;
22971 }
22972 {
22973 PyThreadState* __tstate = wxPyBeginAllowThreads();
22974 (arg1)->SetPrintMode(arg2);
22975
22976 wxPyEndAllowThreads(__tstate);
22977 if (PyErr_Occurred()) SWIG_fail;
22978 }
22979 Py_INCREF(Py_None); resultobj = Py_None;
22980 return resultobj;
22981 fail:
22982 return NULL;
22983 }
22984
22985
22986 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22987 PyObject *resultobj;
22988 wxPyApp *arg1 = (wxPyApp *) 0 ;
22989 int result;
22990 PyObject * obj0 = 0 ;
22991 char *kwnames[] = {
22992 (char *) "self", NULL
22993 };
22994
22995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
22996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22997 if (SWIG_arg_fail(1)) SWIG_fail;
22998 {
22999 PyThreadState* __tstate = wxPyBeginAllowThreads();
23000 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23001
23002 wxPyEndAllowThreads(__tstate);
23003 if (PyErr_Occurred()) SWIG_fail;
23004 }
23005 {
23006 resultobj = SWIG_From_int((int)(result));
23007 }
23008 return resultobj;
23009 fail:
23010 return NULL;
23011 }
23012
23013
23014 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23015 PyObject *resultobj;
23016 wxPyApp *arg1 = (wxPyApp *) 0 ;
23017 int arg2 ;
23018 PyObject * obj0 = 0 ;
23019 PyObject * obj1 = 0 ;
23020 char *kwnames[] = {
23021 (char *) "self",(char *) "mode", NULL
23022 };
23023
23024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23026 if (SWIG_arg_fail(1)) SWIG_fail;
23027 {
23028 arg2 = (int)(SWIG_As_int(obj1));
23029 if (SWIG_arg_fail(2)) SWIG_fail;
23030 }
23031 {
23032 PyThreadState* __tstate = wxPyBeginAllowThreads();
23033 (arg1)->SetAssertMode(arg2);
23034
23035 wxPyEndAllowThreads(__tstate);
23036 if (PyErr_Occurred()) SWIG_fail;
23037 }
23038 Py_INCREF(Py_None); resultobj = Py_None;
23039 return resultobj;
23040 fail:
23041 return NULL;
23042 }
23043
23044
23045 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23046 PyObject *resultobj;
23047 wxPyApp *arg1 = (wxPyApp *) 0 ;
23048 int result;
23049 PyObject * obj0 = 0 ;
23050 char *kwnames[] = {
23051 (char *) "self", NULL
23052 };
23053
23054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23056 if (SWIG_arg_fail(1)) SWIG_fail;
23057 {
23058 PyThreadState* __tstate = wxPyBeginAllowThreads();
23059 result = (int)(arg1)->GetAssertMode();
23060
23061 wxPyEndAllowThreads(__tstate);
23062 if (PyErr_Occurred()) SWIG_fail;
23063 }
23064 {
23065 resultobj = SWIG_From_int((int)(result));
23066 }
23067 return resultobj;
23068 fail:
23069 return NULL;
23070 }
23071
23072
23073 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23074 PyObject *resultobj;
23075 bool result;
23076 char *kwnames[] = {
23077 NULL
23078 };
23079
23080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23081 {
23082 PyThreadState* __tstate = wxPyBeginAllowThreads();
23083 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23084
23085 wxPyEndAllowThreads(__tstate);
23086 if (PyErr_Occurred()) SWIG_fail;
23087 }
23088 {
23089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23090 }
23091 return resultobj;
23092 fail:
23093 return NULL;
23094 }
23095
23096
23097 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23098 PyObject *resultobj;
23099 long result;
23100 char *kwnames[] = {
23101 NULL
23102 };
23103
23104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23105 {
23106 PyThreadState* __tstate = wxPyBeginAllowThreads();
23107 result = (long)wxPyApp::GetMacAboutMenuItemId();
23108
23109 wxPyEndAllowThreads(__tstate);
23110 if (PyErr_Occurred()) SWIG_fail;
23111 }
23112 {
23113 resultobj = SWIG_From_long((long)(result));
23114 }
23115 return resultobj;
23116 fail:
23117 return NULL;
23118 }
23119
23120
23121 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23122 PyObject *resultobj;
23123 long result;
23124 char *kwnames[] = {
23125 NULL
23126 };
23127
23128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23129 {
23130 PyThreadState* __tstate = wxPyBeginAllowThreads();
23131 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23132
23133 wxPyEndAllowThreads(__tstate);
23134 if (PyErr_Occurred()) SWIG_fail;
23135 }
23136 {
23137 resultobj = SWIG_From_long((long)(result));
23138 }
23139 return resultobj;
23140 fail:
23141 return NULL;
23142 }
23143
23144
23145 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23146 PyObject *resultobj;
23147 long result;
23148 char *kwnames[] = {
23149 NULL
23150 };
23151
23152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23153 {
23154 PyThreadState* __tstate = wxPyBeginAllowThreads();
23155 result = (long)wxPyApp::GetMacExitMenuItemId();
23156
23157 wxPyEndAllowThreads(__tstate);
23158 if (PyErr_Occurred()) SWIG_fail;
23159 }
23160 {
23161 resultobj = SWIG_From_long((long)(result));
23162 }
23163 return resultobj;
23164 fail:
23165 return NULL;
23166 }
23167
23168
23169 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23170 PyObject *resultobj;
23171 wxString result;
23172 char *kwnames[] = {
23173 NULL
23174 };
23175
23176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23177 {
23178 PyThreadState* __tstate = wxPyBeginAllowThreads();
23179 result = wxPyApp::GetMacHelpMenuTitleName();
23180
23181 wxPyEndAllowThreads(__tstate);
23182 if (PyErr_Occurred()) SWIG_fail;
23183 }
23184 {
23185 #if wxUSE_UNICODE
23186 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23187 #else
23188 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23189 #endif
23190 }
23191 return resultobj;
23192 fail:
23193 return NULL;
23194 }
23195
23196
23197 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23198 PyObject *resultobj;
23199 bool arg1 ;
23200 PyObject * obj0 = 0 ;
23201 char *kwnames[] = {
23202 (char *) "val", NULL
23203 };
23204
23205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23206 {
23207 arg1 = (bool)(SWIG_As_bool(obj0));
23208 if (SWIG_arg_fail(1)) SWIG_fail;
23209 }
23210 {
23211 PyThreadState* __tstate = wxPyBeginAllowThreads();
23212 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23213
23214 wxPyEndAllowThreads(__tstate);
23215 if (PyErr_Occurred()) SWIG_fail;
23216 }
23217 Py_INCREF(Py_None); resultobj = Py_None;
23218 return resultobj;
23219 fail:
23220 return NULL;
23221 }
23222
23223
23224 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23225 PyObject *resultobj;
23226 long arg1 ;
23227 PyObject * obj0 = 0 ;
23228 char *kwnames[] = {
23229 (char *) "val", NULL
23230 };
23231
23232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23233 {
23234 arg1 = (long)(SWIG_As_long(obj0));
23235 if (SWIG_arg_fail(1)) SWIG_fail;
23236 }
23237 {
23238 PyThreadState* __tstate = wxPyBeginAllowThreads();
23239 wxPyApp::SetMacAboutMenuItemId(arg1);
23240
23241 wxPyEndAllowThreads(__tstate);
23242 if (PyErr_Occurred()) SWIG_fail;
23243 }
23244 Py_INCREF(Py_None); resultobj = Py_None;
23245 return resultobj;
23246 fail:
23247 return NULL;
23248 }
23249
23250
23251 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23252 PyObject *resultobj;
23253 long arg1 ;
23254 PyObject * obj0 = 0 ;
23255 char *kwnames[] = {
23256 (char *) "val", NULL
23257 };
23258
23259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23260 {
23261 arg1 = (long)(SWIG_As_long(obj0));
23262 if (SWIG_arg_fail(1)) SWIG_fail;
23263 }
23264 {
23265 PyThreadState* __tstate = wxPyBeginAllowThreads();
23266 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23267
23268 wxPyEndAllowThreads(__tstate);
23269 if (PyErr_Occurred()) SWIG_fail;
23270 }
23271 Py_INCREF(Py_None); resultobj = Py_None;
23272 return resultobj;
23273 fail:
23274 return NULL;
23275 }
23276
23277
23278 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23279 PyObject *resultobj;
23280 long arg1 ;
23281 PyObject * obj0 = 0 ;
23282 char *kwnames[] = {
23283 (char *) "val", NULL
23284 };
23285
23286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23287 {
23288 arg1 = (long)(SWIG_As_long(obj0));
23289 if (SWIG_arg_fail(1)) SWIG_fail;
23290 }
23291 {
23292 PyThreadState* __tstate = wxPyBeginAllowThreads();
23293 wxPyApp::SetMacExitMenuItemId(arg1);
23294
23295 wxPyEndAllowThreads(__tstate);
23296 if (PyErr_Occurred()) SWIG_fail;
23297 }
23298 Py_INCREF(Py_None); resultobj = Py_None;
23299 return resultobj;
23300 fail:
23301 return NULL;
23302 }
23303
23304
23305 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23306 PyObject *resultobj;
23307 wxString *arg1 = 0 ;
23308 bool temp1 = false ;
23309 PyObject * obj0 = 0 ;
23310 char *kwnames[] = {
23311 (char *) "val", NULL
23312 };
23313
23314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23315 {
23316 arg1 = wxString_in_helper(obj0);
23317 if (arg1 == NULL) SWIG_fail;
23318 temp1 = true;
23319 }
23320 {
23321 PyThreadState* __tstate = wxPyBeginAllowThreads();
23322 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23323
23324 wxPyEndAllowThreads(__tstate);
23325 if (PyErr_Occurred()) SWIG_fail;
23326 }
23327 Py_INCREF(Py_None); resultobj = Py_None;
23328 {
23329 if (temp1)
23330 delete arg1;
23331 }
23332 return resultobj;
23333 fail:
23334 {
23335 if (temp1)
23336 delete arg1;
23337 }
23338 return NULL;
23339 }
23340
23341
23342 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23343 PyObject *resultobj;
23344 wxPyApp *arg1 = (wxPyApp *) 0 ;
23345 PyObject * obj0 = 0 ;
23346 char *kwnames[] = {
23347 (char *) "self", NULL
23348 };
23349
23350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23352 if (SWIG_arg_fail(1)) SWIG_fail;
23353 {
23354 PyThreadState* __tstate = wxPyBeginAllowThreads();
23355 (arg1)->_BootstrapApp();
23356
23357 wxPyEndAllowThreads(__tstate);
23358 if (PyErr_Occurred()) SWIG_fail;
23359 }
23360 Py_INCREF(Py_None); resultobj = Py_None;
23361 return resultobj;
23362 fail:
23363 return NULL;
23364 }
23365
23366
23367 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23368 PyObject *resultobj;
23369 int result;
23370 char *kwnames[] = {
23371 NULL
23372 };
23373
23374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23375 {
23376 PyThreadState* __tstate = wxPyBeginAllowThreads();
23377 result = (int)PyApp_GetComCtl32Version();
23378
23379 wxPyEndAllowThreads(__tstate);
23380 if (PyErr_Occurred()) SWIG_fail;
23381 }
23382 {
23383 resultobj = SWIG_From_int((int)(result));
23384 }
23385 return resultobj;
23386 fail:
23387 return NULL;
23388 }
23389
23390
23391 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23392 PyObject *obj;
23393 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23394 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23395 Py_INCREF(obj);
23396 return Py_BuildValue((char *)"");
23397 }
23398 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23399 PyObject *resultobj;
23400 char *kwnames[] = {
23401 NULL
23402 };
23403
23404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23405 {
23406 PyThreadState* __tstate = wxPyBeginAllowThreads();
23407 wxExit();
23408
23409 wxPyEndAllowThreads(__tstate);
23410 if (PyErr_Occurred()) SWIG_fail;
23411 }
23412 Py_INCREF(Py_None); resultobj = Py_None;
23413 return resultobj;
23414 fail:
23415 return NULL;
23416 }
23417
23418
23419 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23420 PyObject *resultobj;
23421 bool result;
23422 char *kwnames[] = {
23423 NULL
23424 };
23425
23426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23427 {
23428 PyThreadState* __tstate = wxPyBeginAllowThreads();
23429 result = (bool)wxYield();
23430
23431 wxPyEndAllowThreads(__tstate);
23432 if (PyErr_Occurred()) SWIG_fail;
23433 }
23434 {
23435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23436 }
23437 return resultobj;
23438 fail:
23439 return NULL;
23440 }
23441
23442
23443 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23444 PyObject *resultobj;
23445 bool result;
23446 char *kwnames[] = {
23447 NULL
23448 };
23449
23450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23451 {
23452 PyThreadState* __tstate = wxPyBeginAllowThreads();
23453 result = (bool)wxYieldIfNeeded();
23454
23455 wxPyEndAllowThreads(__tstate);
23456 if (PyErr_Occurred()) SWIG_fail;
23457 }
23458 {
23459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23460 }
23461 return resultobj;
23462 fail:
23463 return NULL;
23464 }
23465
23466
23467 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23468 PyObject *resultobj;
23469 wxWindow *arg1 = (wxWindow *) NULL ;
23470 bool arg2 = (bool) false ;
23471 bool result;
23472 PyObject * obj0 = 0 ;
23473 PyObject * obj1 = 0 ;
23474 char *kwnames[] = {
23475 (char *) "win",(char *) "onlyIfNeeded", NULL
23476 };
23477
23478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23479 if (obj0) {
23480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23481 if (SWIG_arg_fail(1)) SWIG_fail;
23482 }
23483 if (obj1) {
23484 {
23485 arg2 = (bool)(SWIG_As_bool(obj1));
23486 if (SWIG_arg_fail(2)) SWIG_fail;
23487 }
23488 }
23489 {
23490 PyThreadState* __tstate = wxPyBeginAllowThreads();
23491 result = (bool)wxSafeYield(arg1,arg2);
23492
23493 wxPyEndAllowThreads(__tstate);
23494 if (PyErr_Occurred()) SWIG_fail;
23495 }
23496 {
23497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23498 }
23499 return resultobj;
23500 fail:
23501 return NULL;
23502 }
23503
23504
23505 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23506 PyObject *resultobj;
23507 char *kwnames[] = {
23508 NULL
23509 };
23510
23511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23512 {
23513 PyThreadState* __tstate = wxPyBeginAllowThreads();
23514 wxWakeUpIdle();
23515
23516 wxPyEndAllowThreads(__tstate);
23517 if (PyErr_Occurred()) SWIG_fail;
23518 }
23519 Py_INCREF(Py_None); resultobj = Py_None;
23520 return resultobj;
23521 fail:
23522 return NULL;
23523 }
23524
23525
23526 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23527 PyObject *resultobj;
23528 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23529 wxEvent *arg2 = 0 ;
23530 PyObject * obj0 = 0 ;
23531 PyObject * obj1 = 0 ;
23532 char *kwnames[] = {
23533 (char *) "dest",(char *) "event", NULL
23534 };
23535
23536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23538 if (SWIG_arg_fail(1)) SWIG_fail;
23539 {
23540 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23541 if (SWIG_arg_fail(2)) SWIG_fail;
23542 if (arg2 == NULL) {
23543 SWIG_null_ref("wxEvent");
23544 }
23545 if (SWIG_arg_fail(2)) SWIG_fail;
23546 }
23547 {
23548 PyThreadState* __tstate = wxPyBeginAllowThreads();
23549 wxPostEvent(arg1,*arg2);
23550
23551 wxPyEndAllowThreads(__tstate);
23552 if (PyErr_Occurred()) SWIG_fail;
23553 }
23554 Py_INCREF(Py_None); resultobj = Py_None;
23555 return resultobj;
23556 fail:
23557 return NULL;
23558 }
23559
23560
23561 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23562 PyObject *resultobj;
23563 char *kwnames[] = {
23564 NULL
23565 };
23566
23567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23568 {
23569 PyThreadState* __tstate = wxPyBeginAllowThreads();
23570 wxApp_CleanUp();
23571
23572 wxPyEndAllowThreads(__tstate);
23573 if (PyErr_Occurred()) SWIG_fail;
23574 }
23575 Py_INCREF(Py_None); resultobj = Py_None;
23576 return resultobj;
23577 fail:
23578 return NULL;
23579 }
23580
23581
23582 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23583 PyObject *resultobj;
23584 wxPyApp *result;
23585 char *kwnames[] = {
23586 NULL
23587 };
23588
23589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23590 {
23591 PyThreadState* __tstate = wxPyBeginAllowThreads();
23592 result = (wxPyApp *)wxPyGetApp();
23593
23594 wxPyEndAllowThreads(__tstate);
23595 if (PyErr_Occurred()) SWIG_fail;
23596 }
23597 {
23598 resultobj = wxPyMake_wxObject(result, 0);
23599 }
23600 return resultobj;
23601 fail:
23602 return NULL;
23603 }
23604
23605
23606 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23607 PyObject *resultobj;
23608 char *arg1 = (char *) 0 ;
23609 PyObject * obj0 = 0 ;
23610 char *kwnames[] = {
23611 (char *) "encoding", NULL
23612 };
23613
23614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23615 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23616 SWIG_arg_fail(1);SWIG_fail;
23617 }
23618 {
23619 PyThreadState* __tstate = wxPyBeginAllowThreads();
23620 wxSetDefaultPyEncoding((char const *)arg1);
23621
23622 wxPyEndAllowThreads(__tstate);
23623 if (PyErr_Occurred()) SWIG_fail;
23624 }
23625 Py_INCREF(Py_None); resultobj = Py_None;
23626 return resultobj;
23627 fail:
23628 return NULL;
23629 }
23630
23631
23632 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23633 PyObject *resultobj;
23634 char *result;
23635 char *kwnames[] = {
23636 NULL
23637 };
23638
23639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23640 {
23641 PyThreadState* __tstate = wxPyBeginAllowThreads();
23642 result = (char *)wxGetDefaultPyEncoding();
23643
23644 wxPyEndAllowThreads(__tstate);
23645 if (PyErr_Occurred()) SWIG_fail;
23646 }
23647 resultobj = SWIG_FromCharPtr(result);
23648 return resultobj;
23649 fail:
23650 return NULL;
23651 }
23652
23653
23654 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23655 PyObject *resultobj;
23656 wxEventLoop *result;
23657 char *kwnames[] = {
23658 NULL
23659 };
23660
23661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23662 {
23663 PyThreadState* __tstate = wxPyBeginAllowThreads();
23664 result = (wxEventLoop *)new wxEventLoop();
23665
23666 wxPyEndAllowThreads(__tstate);
23667 if (PyErr_Occurred()) SWIG_fail;
23668 }
23669 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23670 return resultobj;
23671 fail:
23672 return NULL;
23673 }
23674
23675
23676 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23677 PyObject *resultobj;
23678 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23679 PyObject * obj0 = 0 ;
23680 char *kwnames[] = {
23681 (char *) "self", NULL
23682 };
23683
23684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23686 if (SWIG_arg_fail(1)) SWIG_fail;
23687 {
23688 PyThreadState* __tstate = wxPyBeginAllowThreads();
23689 delete arg1;
23690
23691 wxPyEndAllowThreads(__tstate);
23692 if (PyErr_Occurred()) SWIG_fail;
23693 }
23694 Py_INCREF(Py_None); resultobj = Py_None;
23695 return resultobj;
23696 fail:
23697 return NULL;
23698 }
23699
23700
23701 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23702 PyObject *resultobj;
23703 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23704 int result;
23705 PyObject * obj0 = 0 ;
23706 char *kwnames[] = {
23707 (char *) "self", NULL
23708 };
23709
23710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
23711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23712 if (SWIG_arg_fail(1)) SWIG_fail;
23713 {
23714 PyThreadState* __tstate = wxPyBeginAllowThreads();
23715 result = (int)(arg1)->Run();
23716
23717 wxPyEndAllowThreads(__tstate);
23718 if (PyErr_Occurred()) SWIG_fail;
23719 }
23720 {
23721 resultobj = SWIG_From_int((int)(result));
23722 }
23723 return resultobj;
23724 fail:
23725 return NULL;
23726 }
23727
23728
23729 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23730 PyObject *resultobj;
23731 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23732 int arg2 = (int) 0 ;
23733 PyObject * obj0 = 0 ;
23734 PyObject * obj1 = 0 ;
23735 char *kwnames[] = {
23736 (char *) "self",(char *) "rc", NULL
23737 };
23738
23739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
23740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23741 if (SWIG_arg_fail(1)) SWIG_fail;
23742 if (obj1) {
23743 {
23744 arg2 = (int)(SWIG_As_int(obj1));
23745 if (SWIG_arg_fail(2)) SWIG_fail;
23746 }
23747 }
23748 {
23749 PyThreadState* __tstate = wxPyBeginAllowThreads();
23750 (arg1)->Exit(arg2);
23751
23752 wxPyEndAllowThreads(__tstate);
23753 if (PyErr_Occurred()) SWIG_fail;
23754 }
23755 Py_INCREF(Py_None); resultobj = Py_None;
23756 return resultobj;
23757 fail:
23758 return NULL;
23759 }
23760
23761
23762 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23763 PyObject *resultobj;
23764 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23765 bool result;
23766 PyObject * obj0 = 0 ;
23767 char *kwnames[] = {
23768 (char *) "self", NULL
23769 };
23770
23771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
23772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23773 if (SWIG_arg_fail(1)) SWIG_fail;
23774 {
23775 PyThreadState* __tstate = wxPyBeginAllowThreads();
23776 result = (bool)((wxEventLoop const *)arg1)->Pending();
23777
23778 wxPyEndAllowThreads(__tstate);
23779 if (PyErr_Occurred()) SWIG_fail;
23780 }
23781 {
23782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23783 }
23784 return resultobj;
23785 fail:
23786 return NULL;
23787 }
23788
23789
23790 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23791 PyObject *resultobj;
23792 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23793 bool result;
23794 PyObject * obj0 = 0 ;
23795 char *kwnames[] = {
23796 (char *) "self", NULL
23797 };
23798
23799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
23800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23801 if (SWIG_arg_fail(1)) SWIG_fail;
23802 {
23803 PyThreadState* __tstate = wxPyBeginAllowThreads();
23804 result = (bool)(arg1)->Dispatch();
23805
23806 wxPyEndAllowThreads(__tstate);
23807 if (PyErr_Occurred()) SWIG_fail;
23808 }
23809 {
23810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23811 }
23812 return resultobj;
23813 fail:
23814 return NULL;
23815 }
23816
23817
23818 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23819 PyObject *resultobj;
23820 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23821 bool result;
23822 PyObject * obj0 = 0 ;
23823 char *kwnames[] = {
23824 (char *) "self", NULL
23825 };
23826
23827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
23828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23829 if (SWIG_arg_fail(1)) SWIG_fail;
23830 {
23831 PyThreadState* __tstate = wxPyBeginAllowThreads();
23832 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
23833
23834 wxPyEndAllowThreads(__tstate);
23835 if (PyErr_Occurred()) SWIG_fail;
23836 }
23837 {
23838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23839 }
23840 return resultobj;
23841 fail:
23842 return NULL;
23843 }
23844
23845
23846 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23847 PyObject *resultobj;
23848 wxEventLoop *result;
23849 char *kwnames[] = {
23850 NULL
23851 };
23852
23853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
23854 {
23855 PyThreadState* __tstate = wxPyBeginAllowThreads();
23856 result = (wxEventLoop *)wxEventLoop::GetActive();
23857
23858 wxPyEndAllowThreads(__tstate);
23859 if (PyErr_Occurred()) SWIG_fail;
23860 }
23861 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
23862 return resultobj;
23863 fail:
23864 return NULL;
23865 }
23866
23867
23868 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23869 PyObject *resultobj;
23870 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23871 PyObject * obj0 = 0 ;
23872 char *kwnames[] = {
23873 (char *) "loop", NULL
23874 };
23875
23876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
23877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23878 if (SWIG_arg_fail(1)) SWIG_fail;
23879 {
23880 PyThreadState* __tstate = wxPyBeginAllowThreads();
23881 wxEventLoop::SetActive(arg1);
23882
23883 wxPyEndAllowThreads(__tstate);
23884 if (PyErr_Occurred()) SWIG_fail;
23885 }
23886 Py_INCREF(Py_None); resultobj = Py_None;
23887 return resultobj;
23888 fail:
23889 return NULL;
23890 }
23891
23892
23893 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
23894 PyObject *obj;
23895 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23896 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
23897 Py_INCREF(obj);
23898 return Py_BuildValue((char *)"");
23899 }
23900 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23901 PyObject *resultobj;
23902 int arg1 = (int) 0 ;
23903 int arg2 = (int) 0 ;
23904 int arg3 = (int) 0 ;
23905 wxAcceleratorEntry *result;
23906 PyObject * obj0 = 0 ;
23907 PyObject * obj1 = 0 ;
23908 PyObject * obj2 = 0 ;
23909 char *kwnames[] = {
23910 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
23911 };
23912
23913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
23914 if (obj0) {
23915 {
23916 arg1 = (int)(SWIG_As_int(obj0));
23917 if (SWIG_arg_fail(1)) SWIG_fail;
23918 }
23919 }
23920 if (obj1) {
23921 {
23922 arg2 = (int)(SWIG_As_int(obj1));
23923 if (SWIG_arg_fail(2)) SWIG_fail;
23924 }
23925 }
23926 if (obj2) {
23927 {
23928 arg3 = (int)(SWIG_As_int(obj2));
23929 if (SWIG_arg_fail(3)) SWIG_fail;
23930 }
23931 }
23932 {
23933 PyThreadState* __tstate = wxPyBeginAllowThreads();
23934 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
23935
23936 wxPyEndAllowThreads(__tstate);
23937 if (PyErr_Occurred()) SWIG_fail;
23938 }
23939 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
23940 return resultobj;
23941 fail:
23942 return NULL;
23943 }
23944
23945
23946 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23947 PyObject *resultobj;
23948 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23949 PyObject * obj0 = 0 ;
23950 char *kwnames[] = {
23951 (char *) "self", NULL
23952 };
23953
23954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
23955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23956 if (SWIG_arg_fail(1)) SWIG_fail;
23957 {
23958 PyThreadState* __tstate = wxPyBeginAllowThreads();
23959 delete arg1;
23960
23961 wxPyEndAllowThreads(__tstate);
23962 if (PyErr_Occurred()) SWIG_fail;
23963 }
23964 Py_INCREF(Py_None); resultobj = Py_None;
23965 return resultobj;
23966 fail:
23967 return NULL;
23968 }
23969
23970
23971 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
23972 PyObject *resultobj;
23973 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23974 int arg2 ;
23975 int arg3 ;
23976 int arg4 ;
23977 PyObject * obj0 = 0 ;
23978 PyObject * obj1 = 0 ;
23979 PyObject * obj2 = 0 ;
23980 PyObject * obj3 = 0 ;
23981 char *kwnames[] = {
23982 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
23983 };
23984
23985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23987 if (SWIG_arg_fail(1)) SWIG_fail;
23988 {
23989 arg2 = (int)(SWIG_As_int(obj1));
23990 if (SWIG_arg_fail(2)) SWIG_fail;
23991 }
23992 {
23993 arg3 = (int)(SWIG_As_int(obj2));
23994 if (SWIG_arg_fail(3)) SWIG_fail;
23995 }
23996 {
23997 arg4 = (int)(SWIG_As_int(obj3));
23998 if (SWIG_arg_fail(4)) SWIG_fail;
23999 }
24000 {
24001 PyThreadState* __tstate = wxPyBeginAllowThreads();
24002 (arg1)->Set(arg2,arg3,arg4);
24003
24004 wxPyEndAllowThreads(__tstate);
24005 if (PyErr_Occurred()) SWIG_fail;
24006 }
24007 Py_INCREF(Py_None); resultobj = Py_None;
24008 return resultobj;
24009 fail:
24010 return NULL;
24011 }
24012
24013
24014 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24015 PyObject *resultobj;
24016 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24017 int result;
24018 PyObject * obj0 = 0 ;
24019 char *kwnames[] = {
24020 (char *) "self", NULL
24021 };
24022
24023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24025 if (SWIG_arg_fail(1)) SWIG_fail;
24026 {
24027 PyThreadState* __tstate = wxPyBeginAllowThreads();
24028 result = (int)(arg1)->GetFlags();
24029
24030 wxPyEndAllowThreads(__tstate);
24031 if (PyErr_Occurred()) SWIG_fail;
24032 }
24033 {
24034 resultobj = SWIG_From_int((int)(result));
24035 }
24036 return resultobj;
24037 fail:
24038 return NULL;
24039 }
24040
24041
24042 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24043 PyObject *resultobj;
24044 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24045 int result;
24046 PyObject * obj0 = 0 ;
24047 char *kwnames[] = {
24048 (char *) "self", NULL
24049 };
24050
24051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24053 if (SWIG_arg_fail(1)) SWIG_fail;
24054 {
24055 PyThreadState* __tstate = wxPyBeginAllowThreads();
24056 result = (int)(arg1)->GetKeyCode();
24057
24058 wxPyEndAllowThreads(__tstate);
24059 if (PyErr_Occurred()) SWIG_fail;
24060 }
24061 {
24062 resultobj = SWIG_From_int((int)(result));
24063 }
24064 return resultobj;
24065 fail:
24066 return NULL;
24067 }
24068
24069
24070 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24071 PyObject *resultobj;
24072 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24073 int result;
24074 PyObject * obj0 = 0 ;
24075 char *kwnames[] = {
24076 (char *) "self", NULL
24077 };
24078
24079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24081 if (SWIG_arg_fail(1)) SWIG_fail;
24082 {
24083 PyThreadState* __tstate = wxPyBeginAllowThreads();
24084 result = (int)(arg1)->GetCommand();
24085
24086 wxPyEndAllowThreads(__tstate);
24087 if (PyErr_Occurred()) SWIG_fail;
24088 }
24089 {
24090 resultobj = SWIG_From_int((int)(result));
24091 }
24092 return resultobj;
24093 fail:
24094 return NULL;
24095 }
24096
24097
24098 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24099 PyObject *obj;
24100 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24101 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24102 Py_INCREF(obj);
24103 return Py_BuildValue((char *)"");
24104 }
24105 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24106 PyObject *resultobj;
24107 int arg1 ;
24108 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24109 wxAcceleratorTable *result;
24110 PyObject * obj0 = 0 ;
24111 char *kwnames[] = {
24112 (char *) "n", NULL
24113 };
24114
24115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24116 {
24117 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24118 if (arg2) arg1 = PyList_Size(obj0);
24119 else arg1 = 0;
24120 }
24121 {
24122 PyThreadState* __tstate = wxPyBeginAllowThreads();
24123 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24124
24125 wxPyEndAllowThreads(__tstate);
24126 if (PyErr_Occurred()) SWIG_fail;
24127 }
24128 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24129 {
24130 delete [] arg2;
24131 }
24132 return resultobj;
24133 fail:
24134 {
24135 delete [] arg2;
24136 }
24137 return NULL;
24138 }
24139
24140
24141 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24142 PyObject *resultobj;
24143 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24144 PyObject * obj0 = 0 ;
24145 char *kwnames[] = {
24146 (char *) "self", NULL
24147 };
24148
24149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24151 if (SWIG_arg_fail(1)) SWIG_fail;
24152 {
24153 PyThreadState* __tstate = wxPyBeginAllowThreads();
24154 delete arg1;
24155
24156 wxPyEndAllowThreads(__tstate);
24157 if (PyErr_Occurred()) SWIG_fail;
24158 }
24159 Py_INCREF(Py_None); resultobj = Py_None;
24160 return resultobj;
24161 fail:
24162 return NULL;
24163 }
24164
24165
24166 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24167 PyObject *resultobj;
24168 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24169 bool result;
24170 PyObject * obj0 = 0 ;
24171 char *kwnames[] = {
24172 (char *) "self", NULL
24173 };
24174
24175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24177 if (SWIG_arg_fail(1)) SWIG_fail;
24178 {
24179 PyThreadState* __tstate = wxPyBeginAllowThreads();
24180 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24181
24182 wxPyEndAllowThreads(__tstate);
24183 if (PyErr_Occurred()) SWIG_fail;
24184 }
24185 {
24186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24187 }
24188 return resultobj;
24189 fail:
24190 return NULL;
24191 }
24192
24193
24194 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24195 PyObject *obj;
24196 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24197 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24198 Py_INCREF(obj);
24199 return Py_BuildValue((char *)"");
24200 }
24201 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24202 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24203 return 1;
24204 }
24205
24206
24207 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24208 PyObject *pyobj;
24209
24210 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24211 return pyobj;
24212 }
24213
24214
24215 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24216 PyObject *resultobj;
24217 wxString *arg1 = 0 ;
24218 wxAcceleratorEntry *result;
24219 bool temp1 = false ;
24220 PyObject * obj0 = 0 ;
24221 char *kwnames[] = {
24222 (char *) "label", NULL
24223 };
24224
24225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24226 {
24227 arg1 = wxString_in_helper(obj0);
24228 if (arg1 == NULL) SWIG_fail;
24229 temp1 = true;
24230 }
24231 {
24232 PyThreadState* __tstate = wxPyBeginAllowThreads();
24233 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24234
24235 wxPyEndAllowThreads(__tstate);
24236 if (PyErr_Occurred()) SWIG_fail;
24237 }
24238 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24239 {
24240 if (temp1)
24241 delete arg1;
24242 }
24243 return resultobj;
24244 fail:
24245 {
24246 if (temp1)
24247 delete arg1;
24248 }
24249 return NULL;
24250 }
24251
24252
24253 static int _wrap_PanelNameStr_set(PyObject *) {
24254 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24255 return 1;
24256 }
24257
24258
24259 static PyObject *_wrap_PanelNameStr_get(void) {
24260 PyObject *pyobj;
24261
24262 {
24263 #if wxUSE_UNICODE
24264 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24265 #else
24266 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24267 #endif
24268 }
24269 return pyobj;
24270 }
24271
24272
24273 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24274 PyObject *resultobj;
24275 wxVisualAttributes *result;
24276 char *kwnames[] = {
24277 NULL
24278 };
24279
24280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24281 {
24282 PyThreadState* __tstate = wxPyBeginAllowThreads();
24283 result = (wxVisualAttributes *)new_wxVisualAttributes();
24284
24285 wxPyEndAllowThreads(__tstate);
24286 if (PyErr_Occurred()) SWIG_fail;
24287 }
24288 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24289 return resultobj;
24290 fail:
24291 return NULL;
24292 }
24293
24294
24295 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24296 PyObject *resultobj;
24297 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24298 PyObject * obj0 = 0 ;
24299 char *kwnames[] = {
24300 (char *) "self", NULL
24301 };
24302
24303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24305 if (SWIG_arg_fail(1)) SWIG_fail;
24306 {
24307 PyThreadState* __tstate = wxPyBeginAllowThreads();
24308 delete_wxVisualAttributes(arg1);
24309
24310 wxPyEndAllowThreads(__tstate);
24311 if (PyErr_Occurred()) SWIG_fail;
24312 }
24313 Py_INCREF(Py_None); resultobj = Py_None;
24314 return resultobj;
24315 fail:
24316 return NULL;
24317 }
24318
24319
24320 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24321 PyObject *resultobj;
24322 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24323 wxFont *arg2 = (wxFont *) 0 ;
24324 PyObject * obj0 = 0 ;
24325 PyObject * obj1 = 0 ;
24326 char *kwnames[] = {
24327 (char *) "self",(char *) "font", NULL
24328 };
24329
24330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24332 if (SWIG_arg_fail(1)) SWIG_fail;
24333 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24334 if (SWIG_arg_fail(2)) SWIG_fail;
24335 if (arg1) (arg1)->font = *arg2;
24336
24337 Py_INCREF(Py_None); resultobj = Py_None;
24338 return resultobj;
24339 fail:
24340 return NULL;
24341 }
24342
24343
24344 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24345 PyObject *resultobj;
24346 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24347 wxFont *result;
24348 PyObject * obj0 = 0 ;
24349 char *kwnames[] = {
24350 (char *) "self", NULL
24351 };
24352
24353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24355 if (SWIG_arg_fail(1)) SWIG_fail;
24356 result = (wxFont *)& ((arg1)->font);
24357
24358 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24359 return resultobj;
24360 fail:
24361 return NULL;
24362 }
24363
24364
24365 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24366 PyObject *resultobj;
24367 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24368 wxColour *arg2 = (wxColour *) 0 ;
24369 PyObject * obj0 = 0 ;
24370 PyObject * obj1 = 0 ;
24371 char *kwnames[] = {
24372 (char *) "self",(char *) "colFg", NULL
24373 };
24374
24375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24377 if (SWIG_arg_fail(1)) SWIG_fail;
24378 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24379 if (SWIG_arg_fail(2)) SWIG_fail;
24380 if (arg1) (arg1)->colFg = *arg2;
24381
24382 Py_INCREF(Py_None); resultobj = Py_None;
24383 return resultobj;
24384 fail:
24385 return NULL;
24386 }
24387
24388
24389 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24390 PyObject *resultobj;
24391 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24392 wxColour *result;
24393 PyObject * obj0 = 0 ;
24394 char *kwnames[] = {
24395 (char *) "self", NULL
24396 };
24397
24398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24400 if (SWIG_arg_fail(1)) SWIG_fail;
24401 result = (wxColour *)& ((arg1)->colFg);
24402
24403 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24404 return resultobj;
24405 fail:
24406 return NULL;
24407 }
24408
24409
24410 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24411 PyObject *resultobj;
24412 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24413 wxColour *arg2 = (wxColour *) 0 ;
24414 PyObject * obj0 = 0 ;
24415 PyObject * obj1 = 0 ;
24416 char *kwnames[] = {
24417 (char *) "self",(char *) "colBg", NULL
24418 };
24419
24420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24422 if (SWIG_arg_fail(1)) SWIG_fail;
24423 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24424 if (SWIG_arg_fail(2)) SWIG_fail;
24425 if (arg1) (arg1)->colBg = *arg2;
24426
24427 Py_INCREF(Py_None); resultobj = Py_None;
24428 return resultobj;
24429 fail:
24430 return NULL;
24431 }
24432
24433
24434 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24435 PyObject *resultobj;
24436 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24437 wxColour *result;
24438 PyObject * obj0 = 0 ;
24439 char *kwnames[] = {
24440 (char *) "self", NULL
24441 };
24442
24443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24445 if (SWIG_arg_fail(1)) SWIG_fail;
24446 result = (wxColour *)& ((arg1)->colBg);
24447
24448 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24449 return resultobj;
24450 fail:
24451 return NULL;
24452 }
24453
24454
24455 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24456 PyObject *obj;
24457 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24458 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24459 Py_INCREF(obj);
24460 return Py_BuildValue((char *)"");
24461 }
24462 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24463 PyObject *resultobj;
24464 wxWindow *arg1 = (wxWindow *) 0 ;
24465 int arg2 = (int) (int)-1 ;
24466 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24467 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24468 wxSize const &arg4_defvalue = wxDefaultSize ;
24469 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24470 long arg5 = (long) 0 ;
24471 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24472 wxString *arg6 = (wxString *) &arg6_defvalue ;
24473 wxWindow *result;
24474 wxPoint temp3 ;
24475 wxSize temp4 ;
24476 bool temp6 = false ;
24477 PyObject * obj0 = 0 ;
24478 PyObject * obj1 = 0 ;
24479 PyObject * obj2 = 0 ;
24480 PyObject * obj3 = 0 ;
24481 PyObject * obj4 = 0 ;
24482 PyObject * obj5 = 0 ;
24483 char *kwnames[] = {
24484 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24485 };
24486
24487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24489 if (SWIG_arg_fail(1)) SWIG_fail;
24490 if (obj1) {
24491 {
24492 arg2 = (int const)(SWIG_As_int(obj1));
24493 if (SWIG_arg_fail(2)) SWIG_fail;
24494 }
24495 }
24496 if (obj2) {
24497 {
24498 arg3 = &temp3;
24499 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24500 }
24501 }
24502 if (obj3) {
24503 {
24504 arg4 = &temp4;
24505 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24506 }
24507 }
24508 if (obj4) {
24509 {
24510 arg5 = (long)(SWIG_As_long(obj4));
24511 if (SWIG_arg_fail(5)) SWIG_fail;
24512 }
24513 }
24514 if (obj5) {
24515 {
24516 arg6 = wxString_in_helper(obj5);
24517 if (arg6 == NULL) SWIG_fail;
24518 temp6 = true;
24519 }
24520 }
24521 {
24522 if (!wxPyCheckForApp()) SWIG_fail;
24523 PyThreadState* __tstate = wxPyBeginAllowThreads();
24524 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24525
24526 wxPyEndAllowThreads(__tstate);
24527 if (PyErr_Occurred()) SWIG_fail;
24528 }
24529 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24530 {
24531 if (temp6)
24532 delete arg6;
24533 }
24534 return resultobj;
24535 fail:
24536 {
24537 if (temp6)
24538 delete arg6;
24539 }
24540 return NULL;
24541 }
24542
24543
24544 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24545 PyObject *resultobj;
24546 wxWindow *result;
24547 char *kwnames[] = {
24548 NULL
24549 };
24550
24551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24552 {
24553 if (!wxPyCheckForApp()) SWIG_fail;
24554 PyThreadState* __tstate = wxPyBeginAllowThreads();
24555 result = (wxWindow *)new wxWindow();
24556
24557 wxPyEndAllowThreads(__tstate);
24558 if (PyErr_Occurred()) SWIG_fail;
24559 }
24560 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24561 return resultobj;
24562 fail:
24563 return NULL;
24564 }
24565
24566
24567 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24568 PyObject *resultobj;
24569 wxWindow *arg1 = (wxWindow *) 0 ;
24570 wxWindow *arg2 = (wxWindow *) 0 ;
24571 int arg3 = (int) (int)-1 ;
24572 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24573 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24574 wxSize const &arg5_defvalue = wxDefaultSize ;
24575 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24576 long arg6 = (long) 0 ;
24577 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24578 wxString *arg7 = (wxString *) &arg7_defvalue ;
24579 bool result;
24580 wxPoint temp4 ;
24581 wxSize temp5 ;
24582 bool temp7 = false ;
24583 PyObject * obj0 = 0 ;
24584 PyObject * obj1 = 0 ;
24585 PyObject * obj2 = 0 ;
24586 PyObject * obj3 = 0 ;
24587 PyObject * obj4 = 0 ;
24588 PyObject * obj5 = 0 ;
24589 PyObject * obj6 = 0 ;
24590 char *kwnames[] = {
24591 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24592 };
24593
24594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24596 if (SWIG_arg_fail(1)) SWIG_fail;
24597 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24598 if (SWIG_arg_fail(2)) SWIG_fail;
24599 if (obj2) {
24600 {
24601 arg3 = (int const)(SWIG_As_int(obj2));
24602 if (SWIG_arg_fail(3)) SWIG_fail;
24603 }
24604 }
24605 if (obj3) {
24606 {
24607 arg4 = &temp4;
24608 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24609 }
24610 }
24611 if (obj4) {
24612 {
24613 arg5 = &temp5;
24614 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24615 }
24616 }
24617 if (obj5) {
24618 {
24619 arg6 = (long)(SWIG_As_long(obj5));
24620 if (SWIG_arg_fail(6)) SWIG_fail;
24621 }
24622 }
24623 if (obj6) {
24624 {
24625 arg7 = wxString_in_helper(obj6);
24626 if (arg7 == NULL) SWIG_fail;
24627 temp7 = true;
24628 }
24629 }
24630 {
24631 PyThreadState* __tstate = wxPyBeginAllowThreads();
24632 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24633
24634 wxPyEndAllowThreads(__tstate);
24635 if (PyErr_Occurred()) SWIG_fail;
24636 }
24637 {
24638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24639 }
24640 {
24641 if (temp7)
24642 delete arg7;
24643 }
24644 return resultobj;
24645 fail:
24646 {
24647 if (temp7)
24648 delete arg7;
24649 }
24650 return NULL;
24651 }
24652
24653
24654 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24655 PyObject *resultobj;
24656 wxWindow *arg1 = (wxWindow *) 0 ;
24657 bool arg2 = (bool) false ;
24658 bool result;
24659 PyObject * obj0 = 0 ;
24660 PyObject * obj1 = 0 ;
24661 char *kwnames[] = {
24662 (char *) "self",(char *) "force", NULL
24663 };
24664
24665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24667 if (SWIG_arg_fail(1)) SWIG_fail;
24668 if (obj1) {
24669 {
24670 arg2 = (bool)(SWIG_As_bool(obj1));
24671 if (SWIG_arg_fail(2)) SWIG_fail;
24672 }
24673 }
24674 {
24675 PyThreadState* __tstate = wxPyBeginAllowThreads();
24676 result = (bool)(arg1)->Close(arg2);
24677
24678 wxPyEndAllowThreads(__tstate);
24679 if (PyErr_Occurred()) SWIG_fail;
24680 }
24681 {
24682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24683 }
24684 return resultobj;
24685 fail:
24686 return NULL;
24687 }
24688
24689
24690 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24691 PyObject *resultobj;
24692 wxWindow *arg1 = (wxWindow *) 0 ;
24693 bool result;
24694 PyObject * obj0 = 0 ;
24695 char *kwnames[] = {
24696 (char *) "self", NULL
24697 };
24698
24699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24701 if (SWIG_arg_fail(1)) SWIG_fail;
24702 {
24703 PyThreadState* __tstate = wxPyBeginAllowThreads();
24704 result = (bool)(arg1)->Destroy();
24705
24706 wxPyEndAllowThreads(__tstate);
24707 if (PyErr_Occurred()) SWIG_fail;
24708 }
24709 {
24710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24711 }
24712 return resultobj;
24713 fail:
24714 return NULL;
24715 }
24716
24717
24718 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
24719 PyObject *resultobj;
24720 wxWindow *arg1 = (wxWindow *) 0 ;
24721 bool result;
24722 PyObject * obj0 = 0 ;
24723 char *kwnames[] = {
24724 (char *) "self", NULL
24725 };
24726
24727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
24728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24729 if (SWIG_arg_fail(1)) SWIG_fail;
24730 {
24731 PyThreadState* __tstate = wxPyBeginAllowThreads();
24732 result = (bool)(arg1)->DestroyChildren();
24733
24734 wxPyEndAllowThreads(__tstate);
24735 if (PyErr_Occurred()) SWIG_fail;
24736 }
24737 {
24738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24739 }
24740 return resultobj;
24741 fail:
24742 return NULL;
24743 }
24744
24745
24746 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
24747 PyObject *resultobj;
24748 wxWindow *arg1 = (wxWindow *) 0 ;
24749 bool result;
24750 PyObject * obj0 = 0 ;
24751 char *kwnames[] = {
24752 (char *) "self", NULL
24753 };
24754
24755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
24756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24757 if (SWIG_arg_fail(1)) SWIG_fail;
24758 {
24759 PyThreadState* __tstate = wxPyBeginAllowThreads();
24760 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
24761
24762 wxPyEndAllowThreads(__tstate);
24763 if (PyErr_Occurred()) SWIG_fail;
24764 }
24765 {
24766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24767 }
24768 return resultobj;
24769 fail:
24770 return NULL;
24771 }
24772
24773
24774 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24775 PyObject *resultobj;
24776 wxWindow *arg1 = (wxWindow *) 0 ;
24777 wxString *arg2 = 0 ;
24778 bool temp2 = false ;
24779 PyObject * obj0 = 0 ;
24780 PyObject * obj1 = 0 ;
24781 char *kwnames[] = {
24782 (char *) "self",(char *) "title", NULL
24783 };
24784
24785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
24786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24787 if (SWIG_arg_fail(1)) SWIG_fail;
24788 {
24789 arg2 = wxString_in_helper(obj1);
24790 if (arg2 == NULL) SWIG_fail;
24791 temp2 = true;
24792 }
24793 {
24794 PyThreadState* __tstate = wxPyBeginAllowThreads();
24795 (arg1)->SetTitle((wxString const &)*arg2);
24796
24797 wxPyEndAllowThreads(__tstate);
24798 if (PyErr_Occurred()) SWIG_fail;
24799 }
24800 Py_INCREF(Py_None); resultobj = Py_None;
24801 {
24802 if (temp2)
24803 delete arg2;
24804 }
24805 return resultobj;
24806 fail:
24807 {
24808 if (temp2)
24809 delete arg2;
24810 }
24811 return NULL;
24812 }
24813
24814
24815 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24816 PyObject *resultobj;
24817 wxWindow *arg1 = (wxWindow *) 0 ;
24818 wxString result;
24819 PyObject * obj0 = 0 ;
24820 char *kwnames[] = {
24821 (char *) "self", NULL
24822 };
24823
24824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
24825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24826 if (SWIG_arg_fail(1)) SWIG_fail;
24827 {
24828 PyThreadState* __tstate = wxPyBeginAllowThreads();
24829 result = ((wxWindow const *)arg1)->GetTitle();
24830
24831 wxPyEndAllowThreads(__tstate);
24832 if (PyErr_Occurred()) SWIG_fail;
24833 }
24834 {
24835 #if wxUSE_UNICODE
24836 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24837 #else
24838 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24839 #endif
24840 }
24841 return resultobj;
24842 fail:
24843 return NULL;
24844 }
24845
24846
24847 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24848 PyObject *resultobj;
24849 wxWindow *arg1 = (wxWindow *) 0 ;
24850 wxString *arg2 = 0 ;
24851 bool temp2 = false ;
24852 PyObject * obj0 = 0 ;
24853 PyObject * obj1 = 0 ;
24854 char *kwnames[] = {
24855 (char *) "self",(char *) "label", NULL
24856 };
24857
24858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
24859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24860 if (SWIG_arg_fail(1)) SWIG_fail;
24861 {
24862 arg2 = wxString_in_helper(obj1);
24863 if (arg2 == NULL) SWIG_fail;
24864 temp2 = true;
24865 }
24866 {
24867 PyThreadState* __tstate = wxPyBeginAllowThreads();
24868 (arg1)->SetLabel((wxString const &)*arg2);
24869
24870 wxPyEndAllowThreads(__tstate);
24871 if (PyErr_Occurred()) SWIG_fail;
24872 }
24873 Py_INCREF(Py_None); resultobj = Py_None;
24874 {
24875 if (temp2)
24876 delete arg2;
24877 }
24878 return resultobj;
24879 fail:
24880 {
24881 if (temp2)
24882 delete arg2;
24883 }
24884 return NULL;
24885 }
24886
24887
24888 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24889 PyObject *resultobj;
24890 wxWindow *arg1 = (wxWindow *) 0 ;
24891 wxString result;
24892 PyObject * obj0 = 0 ;
24893 char *kwnames[] = {
24894 (char *) "self", NULL
24895 };
24896
24897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
24898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24899 if (SWIG_arg_fail(1)) SWIG_fail;
24900 {
24901 PyThreadState* __tstate = wxPyBeginAllowThreads();
24902 result = ((wxWindow const *)arg1)->GetLabel();
24903
24904 wxPyEndAllowThreads(__tstate);
24905 if (PyErr_Occurred()) SWIG_fail;
24906 }
24907 {
24908 #if wxUSE_UNICODE
24909 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24910 #else
24911 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24912 #endif
24913 }
24914 return resultobj;
24915 fail:
24916 return NULL;
24917 }
24918
24919
24920 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
24921 PyObject *resultobj;
24922 wxWindow *arg1 = (wxWindow *) 0 ;
24923 wxString *arg2 = 0 ;
24924 bool temp2 = false ;
24925 PyObject * obj0 = 0 ;
24926 PyObject * obj1 = 0 ;
24927 char *kwnames[] = {
24928 (char *) "self",(char *) "name", NULL
24929 };
24930
24931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
24932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24933 if (SWIG_arg_fail(1)) SWIG_fail;
24934 {
24935 arg2 = wxString_in_helper(obj1);
24936 if (arg2 == NULL) SWIG_fail;
24937 temp2 = true;
24938 }
24939 {
24940 PyThreadState* __tstate = wxPyBeginAllowThreads();
24941 (arg1)->SetName((wxString const &)*arg2);
24942
24943 wxPyEndAllowThreads(__tstate);
24944 if (PyErr_Occurred()) SWIG_fail;
24945 }
24946 Py_INCREF(Py_None); resultobj = Py_None;
24947 {
24948 if (temp2)
24949 delete arg2;
24950 }
24951 return resultobj;
24952 fail:
24953 {
24954 if (temp2)
24955 delete arg2;
24956 }
24957 return NULL;
24958 }
24959
24960
24961 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
24962 PyObject *resultobj;
24963 wxWindow *arg1 = (wxWindow *) 0 ;
24964 wxString result;
24965 PyObject * obj0 = 0 ;
24966 char *kwnames[] = {
24967 (char *) "self", NULL
24968 };
24969
24970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
24971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24972 if (SWIG_arg_fail(1)) SWIG_fail;
24973 {
24974 PyThreadState* __tstate = wxPyBeginAllowThreads();
24975 result = ((wxWindow const *)arg1)->GetName();
24976
24977 wxPyEndAllowThreads(__tstate);
24978 if (PyErr_Occurred()) SWIG_fail;
24979 }
24980 {
24981 #if wxUSE_UNICODE
24982 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24983 #else
24984 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24985 #endif
24986 }
24987 return resultobj;
24988 fail:
24989 return NULL;
24990 }
24991
24992
24993 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
24994 PyObject *resultobj;
24995 wxWindow *arg1 = (wxWindow *) 0 ;
24996 wxWindowVariant arg2 ;
24997 PyObject * obj0 = 0 ;
24998 PyObject * obj1 = 0 ;
24999 char *kwnames[] = {
25000 (char *) "self",(char *) "variant", NULL
25001 };
25002
25003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25005 if (SWIG_arg_fail(1)) SWIG_fail;
25006 {
25007 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25008 if (SWIG_arg_fail(2)) SWIG_fail;
25009 }
25010 {
25011 PyThreadState* __tstate = wxPyBeginAllowThreads();
25012 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25013
25014 wxPyEndAllowThreads(__tstate);
25015 if (PyErr_Occurred()) SWIG_fail;
25016 }
25017 Py_INCREF(Py_None); resultobj = Py_None;
25018 return resultobj;
25019 fail:
25020 return NULL;
25021 }
25022
25023
25024 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25025 PyObject *resultobj;
25026 wxWindow *arg1 = (wxWindow *) 0 ;
25027 wxWindowVariant result;
25028 PyObject * obj0 = 0 ;
25029 char *kwnames[] = {
25030 (char *) "self", NULL
25031 };
25032
25033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25035 if (SWIG_arg_fail(1)) SWIG_fail;
25036 {
25037 PyThreadState* __tstate = wxPyBeginAllowThreads();
25038 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25039
25040 wxPyEndAllowThreads(__tstate);
25041 if (PyErr_Occurred()) SWIG_fail;
25042 }
25043 resultobj = SWIG_From_int((result));
25044 return resultobj;
25045 fail:
25046 return NULL;
25047 }
25048
25049
25050 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25051 PyObject *resultobj;
25052 wxWindow *arg1 = (wxWindow *) 0 ;
25053 int arg2 ;
25054 PyObject * obj0 = 0 ;
25055 PyObject * obj1 = 0 ;
25056 char *kwnames[] = {
25057 (char *) "self",(char *) "winid", NULL
25058 };
25059
25060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25062 if (SWIG_arg_fail(1)) SWIG_fail;
25063 {
25064 arg2 = (int)(SWIG_As_int(obj1));
25065 if (SWIG_arg_fail(2)) SWIG_fail;
25066 }
25067 {
25068 PyThreadState* __tstate = wxPyBeginAllowThreads();
25069 (arg1)->SetId(arg2);
25070
25071 wxPyEndAllowThreads(__tstate);
25072 if (PyErr_Occurred()) SWIG_fail;
25073 }
25074 Py_INCREF(Py_None); resultobj = Py_None;
25075 return resultobj;
25076 fail:
25077 return NULL;
25078 }
25079
25080
25081 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25082 PyObject *resultobj;
25083 wxWindow *arg1 = (wxWindow *) 0 ;
25084 int result;
25085 PyObject * obj0 = 0 ;
25086 char *kwnames[] = {
25087 (char *) "self", NULL
25088 };
25089
25090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25092 if (SWIG_arg_fail(1)) SWIG_fail;
25093 {
25094 PyThreadState* __tstate = wxPyBeginAllowThreads();
25095 result = (int)((wxWindow const *)arg1)->GetId();
25096
25097 wxPyEndAllowThreads(__tstate);
25098 if (PyErr_Occurred()) SWIG_fail;
25099 }
25100 {
25101 resultobj = SWIG_From_int((int)(result));
25102 }
25103 return resultobj;
25104 fail:
25105 return NULL;
25106 }
25107
25108
25109 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25110 PyObject *resultobj;
25111 int result;
25112 char *kwnames[] = {
25113 NULL
25114 };
25115
25116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25117 {
25118 PyThreadState* __tstate = wxPyBeginAllowThreads();
25119 result = (int)wxWindow::NewControlId();
25120
25121 wxPyEndAllowThreads(__tstate);
25122 if (PyErr_Occurred()) SWIG_fail;
25123 }
25124 {
25125 resultobj = SWIG_From_int((int)(result));
25126 }
25127 return resultobj;
25128 fail:
25129 return NULL;
25130 }
25131
25132
25133 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25134 PyObject *resultobj;
25135 int arg1 ;
25136 int result;
25137 PyObject * obj0 = 0 ;
25138 char *kwnames[] = {
25139 (char *) "winid", NULL
25140 };
25141
25142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25143 {
25144 arg1 = (int)(SWIG_As_int(obj0));
25145 if (SWIG_arg_fail(1)) SWIG_fail;
25146 }
25147 {
25148 PyThreadState* __tstate = wxPyBeginAllowThreads();
25149 result = (int)wxWindow::NextControlId(arg1);
25150
25151 wxPyEndAllowThreads(__tstate);
25152 if (PyErr_Occurred()) SWIG_fail;
25153 }
25154 {
25155 resultobj = SWIG_From_int((int)(result));
25156 }
25157 return resultobj;
25158 fail:
25159 return NULL;
25160 }
25161
25162
25163 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25164 PyObject *resultobj;
25165 int arg1 ;
25166 int result;
25167 PyObject * obj0 = 0 ;
25168 char *kwnames[] = {
25169 (char *) "winid", NULL
25170 };
25171
25172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25173 {
25174 arg1 = (int)(SWIG_As_int(obj0));
25175 if (SWIG_arg_fail(1)) SWIG_fail;
25176 }
25177 {
25178 PyThreadState* __tstate = wxPyBeginAllowThreads();
25179 result = (int)wxWindow::PrevControlId(arg1);
25180
25181 wxPyEndAllowThreads(__tstate);
25182 if (PyErr_Occurred()) SWIG_fail;
25183 }
25184 {
25185 resultobj = SWIG_From_int((int)(result));
25186 }
25187 return resultobj;
25188 fail:
25189 return NULL;
25190 }
25191
25192
25193 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25194 PyObject *resultobj;
25195 wxWindow *arg1 = (wxWindow *) 0 ;
25196 wxSize *arg2 = 0 ;
25197 wxSize temp2 ;
25198 PyObject * obj0 = 0 ;
25199 PyObject * obj1 = 0 ;
25200 char *kwnames[] = {
25201 (char *) "self",(char *) "size", NULL
25202 };
25203
25204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25206 if (SWIG_arg_fail(1)) SWIG_fail;
25207 {
25208 arg2 = &temp2;
25209 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25210 }
25211 {
25212 PyThreadState* __tstate = wxPyBeginAllowThreads();
25213 (arg1)->SetSize((wxSize const &)*arg2);
25214
25215 wxPyEndAllowThreads(__tstate);
25216 if (PyErr_Occurred()) SWIG_fail;
25217 }
25218 Py_INCREF(Py_None); resultobj = Py_None;
25219 return resultobj;
25220 fail:
25221 return NULL;
25222 }
25223
25224
25225 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25226 PyObject *resultobj;
25227 wxWindow *arg1 = (wxWindow *) 0 ;
25228 int arg2 ;
25229 int arg3 ;
25230 int arg4 ;
25231 int arg5 ;
25232 int arg6 = (int) wxSIZE_AUTO ;
25233 PyObject * obj0 = 0 ;
25234 PyObject * obj1 = 0 ;
25235 PyObject * obj2 = 0 ;
25236 PyObject * obj3 = 0 ;
25237 PyObject * obj4 = 0 ;
25238 PyObject * obj5 = 0 ;
25239 char *kwnames[] = {
25240 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25241 };
25242
25243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25245 if (SWIG_arg_fail(1)) SWIG_fail;
25246 {
25247 arg2 = (int)(SWIG_As_int(obj1));
25248 if (SWIG_arg_fail(2)) SWIG_fail;
25249 }
25250 {
25251 arg3 = (int)(SWIG_As_int(obj2));
25252 if (SWIG_arg_fail(3)) SWIG_fail;
25253 }
25254 {
25255 arg4 = (int)(SWIG_As_int(obj3));
25256 if (SWIG_arg_fail(4)) SWIG_fail;
25257 }
25258 {
25259 arg5 = (int)(SWIG_As_int(obj4));
25260 if (SWIG_arg_fail(5)) SWIG_fail;
25261 }
25262 if (obj5) {
25263 {
25264 arg6 = (int)(SWIG_As_int(obj5));
25265 if (SWIG_arg_fail(6)) SWIG_fail;
25266 }
25267 }
25268 {
25269 PyThreadState* __tstate = wxPyBeginAllowThreads();
25270 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25271
25272 wxPyEndAllowThreads(__tstate);
25273 if (PyErr_Occurred()) SWIG_fail;
25274 }
25275 Py_INCREF(Py_None); resultobj = Py_None;
25276 return resultobj;
25277 fail:
25278 return NULL;
25279 }
25280
25281
25282 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25283 PyObject *resultobj;
25284 wxWindow *arg1 = (wxWindow *) 0 ;
25285 wxRect *arg2 = 0 ;
25286 int arg3 = (int) wxSIZE_AUTO ;
25287 wxRect temp2 ;
25288 PyObject * obj0 = 0 ;
25289 PyObject * obj1 = 0 ;
25290 PyObject * obj2 = 0 ;
25291 char *kwnames[] = {
25292 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25293 };
25294
25295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25297 if (SWIG_arg_fail(1)) SWIG_fail;
25298 {
25299 arg2 = &temp2;
25300 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25301 }
25302 if (obj2) {
25303 {
25304 arg3 = (int)(SWIG_As_int(obj2));
25305 if (SWIG_arg_fail(3)) SWIG_fail;
25306 }
25307 }
25308 {
25309 PyThreadState* __tstate = wxPyBeginAllowThreads();
25310 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25311
25312 wxPyEndAllowThreads(__tstate);
25313 if (PyErr_Occurred()) SWIG_fail;
25314 }
25315 Py_INCREF(Py_None); resultobj = Py_None;
25316 return resultobj;
25317 fail:
25318 return NULL;
25319 }
25320
25321
25322 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25323 PyObject *resultobj;
25324 wxWindow *arg1 = (wxWindow *) 0 ;
25325 int arg2 ;
25326 int arg3 ;
25327 PyObject * obj0 = 0 ;
25328 PyObject * obj1 = 0 ;
25329 PyObject * obj2 = 0 ;
25330 char *kwnames[] = {
25331 (char *) "self",(char *) "width",(char *) "height", NULL
25332 };
25333
25334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25336 if (SWIG_arg_fail(1)) SWIG_fail;
25337 {
25338 arg2 = (int)(SWIG_As_int(obj1));
25339 if (SWIG_arg_fail(2)) SWIG_fail;
25340 }
25341 {
25342 arg3 = (int)(SWIG_As_int(obj2));
25343 if (SWIG_arg_fail(3)) SWIG_fail;
25344 }
25345 {
25346 PyThreadState* __tstate = wxPyBeginAllowThreads();
25347 (arg1)->SetSize(arg2,arg3);
25348
25349 wxPyEndAllowThreads(__tstate);
25350 if (PyErr_Occurred()) SWIG_fail;
25351 }
25352 Py_INCREF(Py_None); resultobj = Py_None;
25353 return resultobj;
25354 fail:
25355 return NULL;
25356 }
25357
25358
25359 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25360 PyObject *resultobj;
25361 wxWindow *arg1 = (wxWindow *) 0 ;
25362 wxPoint *arg2 = 0 ;
25363 int arg3 = (int) wxSIZE_USE_EXISTING ;
25364 wxPoint temp2 ;
25365 PyObject * obj0 = 0 ;
25366 PyObject * obj1 = 0 ;
25367 PyObject * obj2 = 0 ;
25368 char *kwnames[] = {
25369 (char *) "self",(char *) "pt",(char *) "flags", NULL
25370 };
25371
25372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25374 if (SWIG_arg_fail(1)) SWIG_fail;
25375 {
25376 arg2 = &temp2;
25377 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25378 }
25379 if (obj2) {
25380 {
25381 arg3 = (int)(SWIG_As_int(obj2));
25382 if (SWIG_arg_fail(3)) SWIG_fail;
25383 }
25384 }
25385 {
25386 PyThreadState* __tstate = wxPyBeginAllowThreads();
25387 (arg1)->Move((wxPoint const &)*arg2,arg3);
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_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25400 PyObject *resultobj;
25401 wxWindow *arg1 = (wxWindow *) 0 ;
25402 int arg2 ;
25403 int arg3 ;
25404 int arg4 = (int) wxSIZE_USE_EXISTING ;
25405 PyObject * obj0 = 0 ;
25406 PyObject * obj1 = 0 ;
25407 PyObject * obj2 = 0 ;
25408 PyObject * obj3 = 0 ;
25409 char *kwnames[] = {
25410 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25411 };
25412
25413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25415 if (SWIG_arg_fail(1)) SWIG_fail;
25416 {
25417 arg2 = (int)(SWIG_As_int(obj1));
25418 if (SWIG_arg_fail(2)) SWIG_fail;
25419 }
25420 {
25421 arg3 = (int)(SWIG_As_int(obj2));
25422 if (SWIG_arg_fail(3)) SWIG_fail;
25423 }
25424 if (obj3) {
25425 {
25426 arg4 = (int)(SWIG_As_int(obj3));
25427 if (SWIG_arg_fail(4)) SWIG_fail;
25428 }
25429 }
25430 {
25431 PyThreadState* __tstate = wxPyBeginAllowThreads();
25432 (arg1)->Move(arg2,arg3,arg4);
25433
25434 wxPyEndAllowThreads(__tstate);
25435 if (PyErr_Occurred()) SWIG_fail;
25436 }
25437 Py_INCREF(Py_None); resultobj = Py_None;
25438 return resultobj;
25439 fail:
25440 return NULL;
25441 }
25442
25443
25444 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25445 PyObject *resultobj;
25446 wxWindow *arg1 = (wxWindow *) 0 ;
25447 wxSize const &arg2_defvalue = wxDefaultSize ;
25448 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25449 wxSize temp2 ;
25450 PyObject * obj0 = 0 ;
25451 PyObject * obj1 = 0 ;
25452 char *kwnames[] = {
25453 (char *) "self",(char *) "size", NULL
25454 };
25455
25456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25458 if (SWIG_arg_fail(1)) SWIG_fail;
25459 if (obj1) {
25460 {
25461 arg2 = &temp2;
25462 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25463 }
25464 }
25465 {
25466 PyThreadState* __tstate = wxPyBeginAllowThreads();
25467 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25468
25469 wxPyEndAllowThreads(__tstate);
25470 if (PyErr_Occurred()) SWIG_fail;
25471 }
25472 Py_INCREF(Py_None); resultobj = Py_None;
25473 return resultobj;
25474 fail:
25475 return NULL;
25476 }
25477
25478
25479 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25480 PyObject *resultobj;
25481 wxWindow *arg1 = (wxWindow *) 0 ;
25482 PyObject * obj0 = 0 ;
25483 char *kwnames[] = {
25484 (char *) "self", NULL
25485 };
25486
25487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25489 if (SWIG_arg_fail(1)) SWIG_fail;
25490 {
25491 PyThreadState* __tstate = wxPyBeginAllowThreads();
25492 (arg1)->Raise();
25493
25494 wxPyEndAllowThreads(__tstate);
25495 if (PyErr_Occurred()) SWIG_fail;
25496 }
25497 Py_INCREF(Py_None); resultobj = Py_None;
25498 return resultobj;
25499 fail:
25500 return NULL;
25501 }
25502
25503
25504 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25505 PyObject *resultobj;
25506 wxWindow *arg1 = (wxWindow *) 0 ;
25507 PyObject * obj0 = 0 ;
25508 char *kwnames[] = {
25509 (char *) "self", NULL
25510 };
25511
25512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",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 (arg1)->Lower();
25518
25519 wxPyEndAllowThreads(__tstate);
25520 if (PyErr_Occurred()) SWIG_fail;
25521 }
25522 Py_INCREF(Py_None); resultobj = Py_None;
25523 return resultobj;
25524 fail:
25525 return NULL;
25526 }
25527
25528
25529 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25530 PyObject *resultobj;
25531 wxWindow *arg1 = (wxWindow *) 0 ;
25532 wxSize *arg2 = 0 ;
25533 wxSize temp2 ;
25534 PyObject * obj0 = 0 ;
25535 PyObject * obj1 = 0 ;
25536 char *kwnames[] = {
25537 (char *) "self",(char *) "size", NULL
25538 };
25539
25540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25542 if (SWIG_arg_fail(1)) SWIG_fail;
25543 {
25544 arg2 = &temp2;
25545 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25546 }
25547 {
25548 PyThreadState* __tstate = wxPyBeginAllowThreads();
25549 (arg1)->SetClientSize((wxSize const &)*arg2);
25550
25551 wxPyEndAllowThreads(__tstate);
25552 if (PyErr_Occurred()) SWIG_fail;
25553 }
25554 Py_INCREF(Py_None); resultobj = Py_None;
25555 return resultobj;
25556 fail:
25557 return NULL;
25558 }
25559
25560
25561 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25562 PyObject *resultobj;
25563 wxWindow *arg1 = (wxWindow *) 0 ;
25564 int arg2 ;
25565 int arg3 ;
25566 PyObject * obj0 = 0 ;
25567 PyObject * obj1 = 0 ;
25568 PyObject * obj2 = 0 ;
25569 char *kwnames[] = {
25570 (char *) "self",(char *) "width",(char *) "height", NULL
25571 };
25572
25573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25575 if (SWIG_arg_fail(1)) SWIG_fail;
25576 {
25577 arg2 = (int)(SWIG_As_int(obj1));
25578 if (SWIG_arg_fail(2)) SWIG_fail;
25579 }
25580 {
25581 arg3 = (int)(SWIG_As_int(obj2));
25582 if (SWIG_arg_fail(3)) SWIG_fail;
25583 }
25584 {
25585 PyThreadState* __tstate = wxPyBeginAllowThreads();
25586 (arg1)->SetClientSize(arg2,arg3);
25587
25588 wxPyEndAllowThreads(__tstate);
25589 if (PyErr_Occurred()) SWIG_fail;
25590 }
25591 Py_INCREF(Py_None); resultobj = Py_None;
25592 return resultobj;
25593 fail:
25594 return NULL;
25595 }
25596
25597
25598 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25599 PyObject *resultobj;
25600 wxWindow *arg1 = (wxWindow *) 0 ;
25601 wxRect *arg2 = 0 ;
25602 wxRect temp2 ;
25603 PyObject * obj0 = 0 ;
25604 PyObject * obj1 = 0 ;
25605 char *kwnames[] = {
25606 (char *) "self",(char *) "rect", NULL
25607 };
25608
25609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
25614 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25615 }
25616 {
25617 PyThreadState* __tstate = wxPyBeginAllowThreads();
25618 (arg1)->SetClientSize((wxRect const &)*arg2);
25619
25620 wxPyEndAllowThreads(__tstate);
25621 if (PyErr_Occurred()) SWIG_fail;
25622 }
25623 Py_INCREF(Py_None); resultobj = Py_None;
25624 return resultobj;
25625 fail:
25626 return NULL;
25627 }
25628
25629
25630 static PyObject *_wrap_Window_GetPosition(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_GetPosition",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 = (arg1)->GetPosition();
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_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25661 PyObject *resultobj;
25662 wxWindow *arg1 = (wxWindow *) 0 ;
25663 int *arg2 = (int *) 0 ;
25664 int *arg3 = (int *) 0 ;
25665 int temp2 ;
25666 int res2 = 0 ;
25667 int temp3 ;
25668 int res3 = 0 ;
25669 PyObject * obj0 = 0 ;
25670 char *kwnames[] = {
25671 (char *) "self", NULL
25672 };
25673
25674 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25675 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25678 if (SWIG_arg_fail(1)) SWIG_fail;
25679 {
25680 PyThreadState* __tstate = wxPyBeginAllowThreads();
25681 (arg1)->GetPosition(arg2,arg3);
25682
25683 wxPyEndAllowThreads(__tstate);
25684 if (PyErr_Occurred()) SWIG_fail;
25685 }
25686 Py_INCREF(Py_None); resultobj = Py_None;
25687 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25688 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25689 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25690 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25691 return resultobj;
25692 fail:
25693 return NULL;
25694 }
25695
25696
25697 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25698 PyObject *resultobj;
25699 wxWindow *arg1 = (wxWindow *) 0 ;
25700 wxSize result;
25701 PyObject * obj0 = 0 ;
25702 char *kwnames[] = {
25703 (char *) "self", NULL
25704 };
25705
25706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
25707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25708 if (SWIG_arg_fail(1)) SWIG_fail;
25709 {
25710 PyThreadState* __tstate = wxPyBeginAllowThreads();
25711 result = ((wxWindow const *)arg1)->GetSize();
25712
25713 wxPyEndAllowThreads(__tstate);
25714 if (PyErr_Occurred()) SWIG_fail;
25715 }
25716 {
25717 wxSize * resultptr;
25718 resultptr = new wxSize((wxSize &)(result));
25719 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25720 }
25721 return resultobj;
25722 fail:
25723 return NULL;
25724 }
25725
25726
25727 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25728 PyObject *resultobj;
25729 wxWindow *arg1 = (wxWindow *) 0 ;
25730 int *arg2 = (int *) 0 ;
25731 int *arg3 = (int *) 0 ;
25732 int temp2 ;
25733 int res2 = 0 ;
25734 int temp3 ;
25735 int res3 = 0 ;
25736 PyObject * obj0 = 0 ;
25737 char *kwnames[] = {
25738 (char *) "self", NULL
25739 };
25740
25741 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25742 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
25744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25745 if (SWIG_arg_fail(1)) SWIG_fail;
25746 {
25747 PyThreadState* __tstate = wxPyBeginAllowThreads();
25748 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
25749
25750 wxPyEndAllowThreads(__tstate);
25751 if (PyErr_Occurred()) SWIG_fail;
25752 }
25753 Py_INCREF(Py_None); resultobj = Py_None;
25754 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25755 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25756 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25757 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25758 return resultobj;
25759 fail:
25760 return NULL;
25761 }
25762
25763
25764 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25765 PyObject *resultobj;
25766 wxWindow *arg1 = (wxWindow *) 0 ;
25767 wxRect result;
25768 PyObject * obj0 = 0 ;
25769 char *kwnames[] = {
25770 (char *) "self", NULL
25771 };
25772
25773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
25774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25775 if (SWIG_arg_fail(1)) SWIG_fail;
25776 {
25777 PyThreadState* __tstate = wxPyBeginAllowThreads();
25778 result = ((wxWindow const *)arg1)->GetRect();
25779
25780 wxPyEndAllowThreads(__tstate);
25781 if (PyErr_Occurred()) SWIG_fail;
25782 }
25783 {
25784 wxRect * resultptr;
25785 resultptr = new wxRect((wxRect &)(result));
25786 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25787 }
25788 return resultobj;
25789 fail:
25790 return NULL;
25791 }
25792
25793
25794 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25795 PyObject *resultobj;
25796 wxWindow *arg1 = (wxWindow *) 0 ;
25797 wxSize result;
25798 PyObject * obj0 = 0 ;
25799 char *kwnames[] = {
25800 (char *) "self", NULL
25801 };
25802
25803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
25804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25805 if (SWIG_arg_fail(1)) SWIG_fail;
25806 {
25807 PyThreadState* __tstate = wxPyBeginAllowThreads();
25808 result = ((wxWindow const *)arg1)->GetClientSize();
25809
25810 wxPyEndAllowThreads(__tstate);
25811 if (PyErr_Occurred()) SWIG_fail;
25812 }
25813 {
25814 wxSize * resultptr;
25815 resultptr = new wxSize((wxSize &)(result));
25816 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25817 }
25818 return resultobj;
25819 fail:
25820 return NULL;
25821 }
25822
25823
25824 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25825 PyObject *resultobj;
25826 wxWindow *arg1 = (wxWindow *) 0 ;
25827 int *arg2 = (int *) 0 ;
25828 int *arg3 = (int *) 0 ;
25829 int temp2 ;
25830 int res2 = 0 ;
25831 int temp3 ;
25832 int res3 = 0 ;
25833 PyObject * obj0 = 0 ;
25834 char *kwnames[] = {
25835 (char *) "self", NULL
25836 };
25837
25838 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25839 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
25841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25842 if (SWIG_arg_fail(1)) SWIG_fail;
25843 {
25844 PyThreadState* __tstate = wxPyBeginAllowThreads();
25845 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
25846
25847 wxPyEndAllowThreads(__tstate);
25848 if (PyErr_Occurred()) SWIG_fail;
25849 }
25850 Py_INCREF(Py_None); resultobj = Py_None;
25851 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25852 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25853 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25854 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25855 return resultobj;
25856 fail:
25857 return NULL;
25858 }
25859
25860
25861 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
25862 PyObject *resultobj;
25863 wxWindow *arg1 = (wxWindow *) 0 ;
25864 wxPoint result;
25865 PyObject * obj0 = 0 ;
25866 char *kwnames[] = {
25867 (char *) "self", NULL
25868 };
25869
25870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
25871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25872 if (SWIG_arg_fail(1)) SWIG_fail;
25873 {
25874 PyThreadState* __tstate = wxPyBeginAllowThreads();
25875 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
25876
25877 wxPyEndAllowThreads(__tstate);
25878 if (PyErr_Occurred()) SWIG_fail;
25879 }
25880 {
25881 wxPoint * resultptr;
25882 resultptr = new wxPoint((wxPoint &)(result));
25883 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25884 }
25885 return resultobj;
25886 fail:
25887 return NULL;
25888 }
25889
25890
25891 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25892 PyObject *resultobj;
25893 wxWindow *arg1 = (wxWindow *) 0 ;
25894 wxRect result;
25895 PyObject * obj0 = 0 ;
25896 char *kwnames[] = {
25897 (char *) "self", NULL
25898 };
25899
25900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
25901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25902 if (SWIG_arg_fail(1)) SWIG_fail;
25903 {
25904 PyThreadState* __tstate = wxPyBeginAllowThreads();
25905 result = ((wxWindow const *)arg1)->GetClientRect();
25906
25907 wxPyEndAllowThreads(__tstate);
25908 if (PyErr_Occurred()) SWIG_fail;
25909 }
25910 {
25911 wxRect * resultptr;
25912 resultptr = new wxRect((wxRect &)(result));
25913 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25914 }
25915 return resultobj;
25916 fail:
25917 return NULL;
25918 }
25919
25920
25921 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25922 PyObject *resultobj;
25923 wxWindow *arg1 = (wxWindow *) 0 ;
25924 wxSize result;
25925 PyObject * obj0 = 0 ;
25926 char *kwnames[] = {
25927 (char *) "self", NULL
25928 };
25929
25930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
25931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25932 if (SWIG_arg_fail(1)) SWIG_fail;
25933 {
25934 PyThreadState* __tstate = wxPyBeginAllowThreads();
25935 result = ((wxWindow const *)arg1)->GetBestSize();
25936
25937 wxPyEndAllowThreads(__tstate);
25938 if (PyErr_Occurred()) SWIG_fail;
25939 }
25940 {
25941 wxSize * resultptr;
25942 resultptr = new wxSize((wxSize &)(result));
25943 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25944 }
25945 return resultobj;
25946 fail:
25947 return NULL;
25948 }
25949
25950
25951 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25952 PyObject *resultobj;
25953 wxWindow *arg1 = (wxWindow *) 0 ;
25954 int *arg2 = (int *) 0 ;
25955 int *arg3 = (int *) 0 ;
25956 int temp2 ;
25957 int res2 = 0 ;
25958 int temp3 ;
25959 int res3 = 0 ;
25960 PyObject * obj0 = 0 ;
25961 char *kwnames[] = {
25962 (char *) "self", NULL
25963 };
25964
25965 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25966 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
25968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25969 if (SWIG_arg_fail(1)) SWIG_fail;
25970 {
25971 PyThreadState* __tstate = wxPyBeginAllowThreads();
25972 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
25973
25974 wxPyEndAllowThreads(__tstate);
25975 if (PyErr_Occurred()) SWIG_fail;
25976 }
25977 Py_INCREF(Py_None); resultobj = Py_None;
25978 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25979 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25980 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25981 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25982 return resultobj;
25983 fail:
25984 return NULL;
25985 }
25986
25987
25988 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25989 PyObject *resultobj;
25990 wxWindow *arg1 = (wxWindow *) 0 ;
25991 PyObject * obj0 = 0 ;
25992 char *kwnames[] = {
25993 (char *) "self", NULL
25994 };
25995
25996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
25997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25998 if (SWIG_arg_fail(1)) SWIG_fail;
25999 {
26000 PyThreadState* __tstate = wxPyBeginAllowThreads();
26001 (arg1)->InvalidateBestSize();
26002
26003 wxPyEndAllowThreads(__tstate);
26004 if (PyErr_Occurred()) SWIG_fail;
26005 }
26006 Py_INCREF(Py_None); resultobj = Py_None;
26007 return resultobj;
26008 fail:
26009 return NULL;
26010 }
26011
26012
26013 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26014 PyObject *resultobj;
26015 wxWindow *arg1 = (wxWindow *) 0 ;
26016 wxSize result;
26017 PyObject * obj0 = 0 ;
26018 char *kwnames[] = {
26019 (char *) "self", NULL
26020 };
26021
26022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26024 if (SWIG_arg_fail(1)) SWIG_fail;
26025 {
26026 PyThreadState* __tstate = wxPyBeginAllowThreads();
26027 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26028
26029 wxPyEndAllowThreads(__tstate);
26030 if (PyErr_Occurred()) SWIG_fail;
26031 }
26032 {
26033 wxSize * resultptr;
26034 resultptr = new wxSize((wxSize &)(result));
26035 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26036 }
26037 return resultobj;
26038 fail:
26039 return NULL;
26040 }
26041
26042
26043 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26044 PyObject *resultobj;
26045 wxWindow *arg1 = (wxWindow *) 0 ;
26046 wxSize result;
26047 PyObject * obj0 = 0 ;
26048 char *kwnames[] = {
26049 (char *) "self", NULL
26050 };
26051
26052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26054 if (SWIG_arg_fail(1)) SWIG_fail;
26055 {
26056 PyThreadState* __tstate = wxPyBeginAllowThreads();
26057 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26058
26059 wxPyEndAllowThreads(__tstate);
26060 if (PyErr_Occurred()) SWIG_fail;
26061 }
26062 {
26063 wxSize * resultptr;
26064 resultptr = new wxSize((wxSize &)(result));
26065 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26066 }
26067 return resultobj;
26068 fail:
26069 return NULL;
26070 }
26071
26072
26073 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26074 PyObject *resultobj;
26075 wxWindow *arg1 = (wxWindow *) 0 ;
26076 int arg2 = (int) wxBOTH ;
26077 PyObject * obj0 = 0 ;
26078 PyObject * obj1 = 0 ;
26079 char *kwnames[] = {
26080 (char *) "self",(char *) "direction", NULL
26081 };
26082
26083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26085 if (SWIG_arg_fail(1)) SWIG_fail;
26086 if (obj1) {
26087 {
26088 arg2 = (int)(SWIG_As_int(obj1));
26089 if (SWIG_arg_fail(2)) SWIG_fail;
26090 }
26091 }
26092 {
26093 PyThreadState* __tstate = wxPyBeginAllowThreads();
26094 (arg1)->Center(arg2);
26095
26096 wxPyEndAllowThreads(__tstate);
26097 if (PyErr_Occurred()) SWIG_fail;
26098 }
26099 Py_INCREF(Py_None); resultobj = Py_None;
26100 return resultobj;
26101 fail:
26102 return NULL;
26103 }
26104
26105
26106 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26107 PyObject *resultobj;
26108 wxWindow *arg1 = (wxWindow *) 0 ;
26109 int arg2 = (int) wxBOTH ;
26110 PyObject * obj0 = 0 ;
26111 PyObject * obj1 = 0 ;
26112 char *kwnames[] = {
26113 (char *) "self",(char *) "dir", NULL
26114 };
26115
26116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26118 if (SWIG_arg_fail(1)) SWIG_fail;
26119 if (obj1) {
26120 {
26121 arg2 = (int)(SWIG_As_int(obj1));
26122 if (SWIG_arg_fail(2)) SWIG_fail;
26123 }
26124 }
26125 {
26126 PyThreadState* __tstate = wxPyBeginAllowThreads();
26127 (arg1)->CenterOnScreen(arg2);
26128
26129 wxPyEndAllowThreads(__tstate);
26130 if (PyErr_Occurred()) SWIG_fail;
26131 }
26132 Py_INCREF(Py_None); resultobj = Py_None;
26133 return resultobj;
26134 fail:
26135 return NULL;
26136 }
26137
26138
26139 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26140 PyObject *resultobj;
26141 wxWindow *arg1 = (wxWindow *) 0 ;
26142 int arg2 = (int) wxBOTH ;
26143 PyObject * obj0 = 0 ;
26144 PyObject * obj1 = 0 ;
26145 char *kwnames[] = {
26146 (char *) "self",(char *) "dir", NULL
26147 };
26148
26149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26151 if (SWIG_arg_fail(1)) SWIG_fail;
26152 if (obj1) {
26153 {
26154 arg2 = (int)(SWIG_As_int(obj1));
26155 if (SWIG_arg_fail(2)) SWIG_fail;
26156 }
26157 }
26158 {
26159 PyThreadState* __tstate = wxPyBeginAllowThreads();
26160 (arg1)->CenterOnParent(arg2);
26161
26162 wxPyEndAllowThreads(__tstate);
26163 if (PyErr_Occurred()) SWIG_fail;
26164 }
26165 Py_INCREF(Py_None); resultobj = Py_None;
26166 return resultobj;
26167 fail:
26168 return NULL;
26169 }
26170
26171
26172 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26173 PyObject *resultobj;
26174 wxWindow *arg1 = (wxWindow *) 0 ;
26175 PyObject * obj0 = 0 ;
26176 char *kwnames[] = {
26177 (char *) "self", NULL
26178 };
26179
26180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
26185 (arg1)->Fit();
26186
26187 wxPyEndAllowThreads(__tstate);
26188 if (PyErr_Occurred()) SWIG_fail;
26189 }
26190 Py_INCREF(Py_None); resultobj = Py_None;
26191 return resultobj;
26192 fail:
26193 return NULL;
26194 }
26195
26196
26197 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26198 PyObject *resultobj;
26199 wxWindow *arg1 = (wxWindow *) 0 ;
26200 PyObject * obj0 = 0 ;
26201 char *kwnames[] = {
26202 (char *) "self", NULL
26203 };
26204
26205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26207 if (SWIG_arg_fail(1)) SWIG_fail;
26208 {
26209 PyThreadState* __tstate = wxPyBeginAllowThreads();
26210 (arg1)->FitInside();
26211
26212 wxPyEndAllowThreads(__tstate);
26213 if (PyErr_Occurred()) SWIG_fail;
26214 }
26215 Py_INCREF(Py_None); resultobj = Py_None;
26216 return resultobj;
26217 fail:
26218 return NULL;
26219 }
26220
26221
26222 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26223 PyObject *resultobj;
26224 wxWindow *arg1 = (wxWindow *) 0 ;
26225 int arg2 ;
26226 int arg3 ;
26227 int arg4 = (int) -1 ;
26228 int arg5 = (int) -1 ;
26229 int arg6 = (int) -1 ;
26230 int arg7 = (int) -1 ;
26231 PyObject * obj0 = 0 ;
26232 PyObject * obj1 = 0 ;
26233 PyObject * obj2 = 0 ;
26234 PyObject * obj3 = 0 ;
26235 PyObject * obj4 = 0 ;
26236 PyObject * obj5 = 0 ;
26237 PyObject * obj6 = 0 ;
26238 char *kwnames[] = {
26239 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26240 };
26241
26242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26244 if (SWIG_arg_fail(1)) SWIG_fail;
26245 {
26246 arg2 = (int)(SWIG_As_int(obj1));
26247 if (SWIG_arg_fail(2)) SWIG_fail;
26248 }
26249 {
26250 arg3 = (int)(SWIG_As_int(obj2));
26251 if (SWIG_arg_fail(3)) SWIG_fail;
26252 }
26253 if (obj3) {
26254 {
26255 arg4 = (int)(SWIG_As_int(obj3));
26256 if (SWIG_arg_fail(4)) SWIG_fail;
26257 }
26258 }
26259 if (obj4) {
26260 {
26261 arg5 = (int)(SWIG_As_int(obj4));
26262 if (SWIG_arg_fail(5)) SWIG_fail;
26263 }
26264 }
26265 if (obj5) {
26266 {
26267 arg6 = (int)(SWIG_As_int(obj5));
26268 if (SWIG_arg_fail(6)) SWIG_fail;
26269 }
26270 }
26271 if (obj6) {
26272 {
26273 arg7 = (int)(SWIG_As_int(obj6));
26274 if (SWIG_arg_fail(7)) SWIG_fail;
26275 }
26276 }
26277 {
26278 PyThreadState* __tstate = wxPyBeginAllowThreads();
26279 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26280
26281 wxPyEndAllowThreads(__tstate);
26282 if (PyErr_Occurred()) SWIG_fail;
26283 }
26284 Py_INCREF(Py_None); resultobj = Py_None;
26285 return resultobj;
26286 fail:
26287 return NULL;
26288 }
26289
26290
26291 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26292 PyObject *resultobj;
26293 wxWindow *arg1 = (wxWindow *) 0 ;
26294 wxSize *arg2 = 0 ;
26295 wxSize const &arg3_defvalue = wxDefaultSize ;
26296 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26297 wxSize const &arg4_defvalue = wxDefaultSize ;
26298 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26299 wxSize temp2 ;
26300 wxSize temp3 ;
26301 wxSize temp4 ;
26302 PyObject * obj0 = 0 ;
26303 PyObject * obj1 = 0 ;
26304 PyObject * obj2 = 0 ;
26305 PyObject * obj3 = 0 ;
26306 char *kwnames[] = {
26307 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26308 };
26309
26310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 if (obj2) {
26318 {
26319 arg3 = &temp3;
26320 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26321 }
26322 }
26323 if (obj3) {
26324 {
26325 arg4 = &temp4;
26326 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26327 }
26328 }
26329 {
26330 PyThreadState* __tstate = wxPyBeginAllowThreads();
26331 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26332
26333 wxPyEndAllowThreads(__tstate);
26334 if (PyErr_Occurred()) SWIG_fail;
26335 }
26336 Py_INCREF(Py_None); resultobj = Py_None;
26337 return resultobj;
26338 fail:
26339 return NULL;
26340 }
26341
26342
26343 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26344 PyObject *resultobj;
26345 wxWindow *arg1 = (wxWindow *) 0 ;
26346 int arg2 ;
26347 int arg3 ;
26348 int arg4 = (int) -1 ;
26349 int arg5 = (int) -1 ;
26350 PyObject * obj0 = 0 ;
26351 PyObject * obj1 = 0 ;
26352 PyObject * obj2 = 0 ;
26353 PyObject * obj3 = 0 ;
26354 PyObject * obj4 = 0 ;
26355 char *kwnames[] = {
26356 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26357 };
26358
26359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26361 if (SWIG_arg_fail(1)) SWIG_fail;
26362 {
26363 arg2 = (int)(SWIG_As_int(obj1));
26364 if (SWIG_arg_fail(2)) SWIG_fail;
26365 }
26366 {
26367 arg3 = (int)(SWIG_As_int(obj2));
26368 if (SWIG_arg_fail(3)) SWIG_fail;
26369 }
26370 if (obj3) {
26371 {
26372 arg4 = (int)(SWIG_As_int(obj3));
26373 if (SWIG_arg_fail(4)) SWIG_fail;
26374 }
26375 }
26376 if (obj4) {
26377 {
26378 arg5 = (int)(SWIG_As_int(obj4));
26379 if (SWIG_arg_fail(5)) SWIG_fail;
26380 }
26381 }
26382 {
26383 PyThreadState* __tstate = wxPyBeginAllowThreads();
26384 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26385
26386 wxPyEndAllowThreads(__tstate);
26387 if (PyErr_Occurred()) SWIG_fail;
26388 }
26389 Py_INCREF(Py_None); resultobj = Py_None;
26390 return resultobj;
26391 fail:
26392 return NULL;
26393 }
26394
26395
26396 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26397 PyObject *resultobj;
26398 wxWindow *arg1 = (wxWindow *) 0 ;
26399 wxSize *arg2 = 0 ;
26400 wxSize const &arg3_defvalue = wxDefaultSize ;
26401 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26402 wxSize temp2 ;
26403 wxSize temp3 ;
26404 PyObject * obj0 = 0 ;
26405 PyObject * obj1 = 0 ;
26406 PyObject * obj2 = 0 ;
26407 char *kwnames[] = {
26408 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26409 };
26410
26411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26413 if (SWIG_arg_fail(1)) SWIG_fail;
26414 {
26415 arg2 = &temp2;
26416 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26417 }
26418 if (obj2) {
26419 {
26420 arg3 = &temp3;
26421 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26422 }
26423 }
26424 {
26425 PyThreadState* __tstate = wxPyBeginAllowThreads();
26426 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26427
26428 wxPyEndAllowThreads(__tstate);
26429 if (PyErr_Occurred()) SWIG_fail;
26430 }
26431 Py_INCREF(Py_None); resultobj = Py_None;
26432 return resultobj;
26433 fail:
26434 return NULL;
26435 }
26436
26437
26438 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26439 PyObject *resultobj;
26440 wxWindow *arg1 = (wxWindow *) 0 ;
26441 wxSize result;
26442 PyObject * obj0 = 0 ;
26443 char *kwnames[] = {
26444 (char *) "self", NULL
26445 };
26446
26447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26449 if (SWIG_arg_fail(1)) SWIG_fail;
26450 {
26451 PyThreadState* __tstate = wxPyBeginAllowThreads();
26452 result = ((wxWindow const *)arg1)->GetMaxSize();
26453
26454 wxPyEndAllowThreads(__tstate);
26455 if (PyErr_Occurred()) SWIG_fail;
26456 }
26457 {
26458 wxSize * resultptr;
26459 resultptr = new wxSize((wxSize &)(result));
26460 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26461 }
26462 return resultobj;
26463 fail:
26464 return NULL;
26465 }
26466
26467
26468 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26469 PyObject *resultobj;
26470 wxWindow *arg1 = (wxWindow *) 0 ;
26471 wxSize result;
26472 PyObject * obj0 = 0 ;
26473 char *kwnames[] = {
26474 (char *) "self", NULL
26475 };
26476
26477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26479 if (SWIG_arg_fail(1)) SWIG_fail;
26480 {
26481 PyThreadState* __tstate = wxPyBeginAllowThreads();
26482 result = ((wxWindow const *)arg1)->GetMinSize();
26483
26484 wxPyEndAllowThreads(__tstate);
26485 if (PyErr_Occurred()) SWIG_fail;
26486 }
26487 {
26488 wxSize * resultptr;
26489 resultptr = new wxSize((wxSize &)(result));
26490 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26491 }
26492 return resultobj;
26493 fail:
26494 return NULL;
26495 }
26496
26497
26498 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26499 PyObject *resultobj;
26500 wxWindow *arg1 = (wxWindow *) 0 ;
26501 wxSize *arg2 = 0 ;
26502 wxSize temp2 ;
26503 PyObject * obj0 = 0 ;
26504 PyObject * obj1 = 0 ;
26505 char *kwnames[] = {
26506 (char *) "self",(char *) "minSize", NULL
26507 };
26508
26509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26511 if (SWIG_arg_fail(1)) SWIG_fail;
26512 {
26513 arg2 = &temp2;
26514 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26515 }
26516 {
26517 PyThreadState* __tstate = wxPyBeginAllowThreads();
26518 (arg1)->SetMinSize((wxSize const &)*arg2);
26519
26520 wxPyEndAllowThreads(__tstate);
26521 if (PyErr_Occurred()) SWIG_fail;
26522 }
26523 Py_INCREF(Py_None); resultobj = Py_None;
26524 return resultobj;
26525 fail:
26526 return NULL;
26527 }
26528
26529
26530 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26531 PyObject *resultobj;
26532 wxWindow *arg1 = (wxWindow *) 0 ;
26533 wxSize *arg2 = 0 ;
26534 wxSize temp2 ;
26535 PyObject * obj0 = 0 ;
26536 PyObject * obj1 = 0 ;
26537 char *kwnames[] = {
26538 (char *) "self",(char *) "maxSize", NULL
26539 };
26540
26541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26543 if (SWIG_arg_fail(1)) SWIG_fail;
26544 {
26545 arg2 = &temp2;
26546 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26547 }
26548 {
26549 PyThreadState* __tstate = wxPyBeginAllowThreads();
26550 (arg1)->SetMaxSize((wxSize const &)*arg2);
26551
26552 wxPyEndAllowThreads(__tstate);
26553 if (PyErr_Occurred()) SWIG_fail;
26554 }
26555 Py_INCREF(Py_None); resultobj = Py_None;
26556 return resultobj;
26557 fail:
26558 return NULL;
26559 }
26560
26561
26562 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26563 PyObject *resultobj;
26564 wxWindow *arg1 = (wxWindow *) 0 ;
26565 int result;
26566 PyObject * obj0 = 0 ;
26567 char *kwnames[] = {
26568 (char *) "self", NULL
26569 };
26570
26571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
26572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26573 if (SWIG_arg_fail(1)) SWIG_fail;
26574 {
26575 PyThreadState* __tstate = wxPyBeginAllowThreads();
26576 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26577
26578 wxPyEndAllowThreads(__tstate);
26579 if (PyErr_Occurred()) SWIG_fail;
26580 }
26581 {
26582 resultobj = SWIG_From_int((int)(result));
26583 }
26584 return resultobj;
26585 fail:
26586 return NULL;
26587 }
26588
26589
26590 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26591 PyObject *resultobj;
26592 wxWindow *arg1 = (wxWindow *) 0 ;
26593 int result;
26594 PyObject * obj0 = 0 ;
26595 char *kwnames[] = {
26596 (char *) "self", NULL
26597 };
26598
26599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26601 if (SWIG_arg_fail(1)) SWIG_fail;
26602 {
26603 PyThreadState* __tstate = wxPyBeginAllowThreads();
26604 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26605
26606 wxPyEndAllowThreads(__tstate);
26607 if (PyErr_Occurred()) SWIG_fail;
26608 }
26609 {
26610 resultobj = SWIG_From_int((int)(result));
26611 }
26612 return resultobj;
26613 fail:
26614 return NULL;
26615 }
26616
26617
26618 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26619 PyObject *resultobj;
26620 wxWindow *arg1 = (wxWindow *) 0 ;
26621 int result;
26622 PyObject * obj0 = 0 ;
26623 char *kwnames[] = {
26624 (char *) "self", NULL
26625 };
26626
26627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26629 if (SWIG_arg_fail(1)) SWIG_fail;
26630 {
26631 PyThreadState* __tstate = wxPyBeginAllowThreads();
26632 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26633
26634 wxPyEndAllowThreads(__tstate);
26635 if (PyErr_Occurred()) SWIG_fail;
26636 }
26637 {
26638 resultobj = SWIG_From_int((int)(result));
26639 }
26640 return resultobj;
26641 fail:
26642 return NULL;
26643 }
26644
26645
26646 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26647 PyObject *resultobj;
26648 wxWindow *arg1 = (wxWindow *) 0 ;
26649 int result;
26650 PyObject * obj0 = 0 ;
26651 char *kwnames[] = {
26652 (char *) "self", NULL
26653 };
26654
26655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26657 if (SWIG_arg_fail(1)) SWIG_fail;
26658 {
26659 PyThreadState* __tstate = wxPyBeginAllowThreads();
26660 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26661
26662 wxPyEndAllowThreads(__tstate);
26663 if (PyErr_Occurred()) SWIG_fail;
26664 }
26665 {
26666 resultobj = SWIG_From_int((int)(result));
26667 }
26668 return resultobj;
26669 fail:
26670 return NULL;
26671 }
26672
26673
26674 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26675 PyObject *resultobj;
26676 wxWindow *arg1 = (wxWindow *) 0 ;
26677 wxSize *arg2 = 0 ;
26678 wxSize temp2 ;
26679 PyObject * obj0 = 0 ;
26680 PyObject * obj1 = 0 ;
26681 char *kwnames[] = {
26682 (char *) "self",(char *) "size", NULL
26683 };
26684
26685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26687 if (SWIG_arg_fail(1)) SWIG_fail;
26688 {
26689 arg2 = &temp2;
26690 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26691 }
26692 {
26693 PyThreadState* __tstate = wxPyBeginAllowThreads();
26694 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26695
26696 wxPyEndAllowThreads(__tstate);
26697 if (PyErr_Occurred()) SWIG_fail;
26698 }
26699 Py_INCREF(Py_None); resultobj = Py_None;
26700 return resultobj;
26701 fail:
26702 return NULL;
26703 }
26704
26705
26706 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26707 PyObject *resultobj;
26708 wxWindow *arg1 = (wxWindow *) 0 ;
26709 int arg2 ;
26710 int arg3 ;
26711 PyObject * obj0 = 0 ;
26712 PyObject * obj1 = 0 ;
26713 PyObject * obj2 = 0 ;
26714 char *kwnames[] = {
26715 (char *) "self",(char *) "w",(char *) "h", NULL
26716 };
26717
26718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = (int)(SWIG_As_int(obj1));
26723 if (SWIG_arg_fail(2)) SWIG_fail;
26724 }
26725 {
26726 arg3 = (int)(SWIG_As_int(obj2));
26727 if (SWIG_arg_fail(3)) SWIG_fail;
26728 }
26729 {
26730 PyThreadState* __tstate = wxPyBeginAllowThreads();
26731 (arg1)->SetVirtualSize(arg2,arg3);
26732
26733 wxPyEndAllowThreads(__tstate);
26734 if (PyErr_Occurred()) SWIG_fail;
26735 }
26736 Py_INCREF(Py_None); resultobj = Py_None;
26737 return resultobj;
26738 fail:
26739 return NULL;
26740 }
26741
26742
26743 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26744 PyObject *resultobj;
26745 wxWindow *arg1 = (wxWindow *) 0 ;
26746 wxSize result;
26747 PyObject * obj0 = 0 ;
26748 char *kwnames[] = {
26749 (char *) "self", NULL
26750 };
26751
26752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
26753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26754 if (SWIG_arg_fail(1)) SWIG_fail;
26755 {
26756 PyThreadState* __tstate = wxPyBeginAllowThreads();
26757 result = ((wxWindow const *)arg1)->GetVirtualSize();
26758
26759 wxPyEndAllowThreads(__tstate);
26760 if (PyErr_Occurred()) SWIG_fail;
26761 }
26762 {
26763 wxSize * resultptr;
26764 resultptr = new wxSize((wxSize &)(result));
26765 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26766 }
26767 return resultobj;
26768 fail:
26769 return NULL;
26770 }
26771
26772
26773 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26774 PyObject *resultobj;
26775 wxWindow *arg1 = (wxWindow *) 0 ;
26776 int *arg2 = (int *) 0 ;
26777 int *arg3 = (int *) 0 ;
26778 int temp2 ;
26779 int res2 = 0 ;
26780 int temp3 ;
26781 int res3 = 0 ;
26782 PyObject * obj0 = 0 ;
26783 char *kwnames[] = {
26784 (char *) "self", NULL
26785 };
26786
26787 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26788 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
26790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26791 if (SWIG_arg_fail(1)) SWIG_fail;
26792 {
26793 PyThreadState* __tstate = wxPyBeginAllowThreads();
26794 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
26795
26796 wxPyEndAllowThreads(__tstate);
26797 if (PyErr_Occurred()) SWIG_fail;
26798 }
26799 Py_INCREF(Py_None); resultobj = Py_None;
26800 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26801 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26802 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26803 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26804 return resultobj;
26805 fail:
26806 return NULL;
26807 }
26808
26809
26810 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26811 PyObject *resultobj;
26812 wxWindow *arg1 = (wxWindow *) 0 ;
26813 wxSize result;
26814 PyObject * obj0 = 0 ;
26815 char *kwnames[] = {
26816 (char *) "self", NULL
26817 };
26818
26819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
26820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26821 if (SWIG_arg_fail(1)) SWIG_fail;
26822 {
26823 PyThreadState* __tstate = wxPyBeginAllowThreads();
26824 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
26825
26826 wxPyEndAllowThreads(__tstate);
26827 if (PyErr_Occurred()) SWIG_fail;
26828 }
26829 {
26830 wxSize * resultptr;
26831 resultptr = new wxSize((wxSize &)(result));
26832 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26833 }
26834 return resultobj;
26835 fail:
26836 return NULL;
26837 }
26838
26839
26840 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
26841 PyObject *resultobj;
26842 wxWindow *arg1 = (wxWindow *) 0 ;
26843 bool arg2 = (bool) true ;
26844 bool result;
26845 PyObject * obj0 = 0 ;
26846 PyObject * obj1 = 0 ;
26847 char *kwnames[] = {
26848 (char *) "self",(char *) "show", NULL
26849 };
26850
26851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
26852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26853 if (SWIG_arg_fail(1)) SWIG_fail;
26854 if (obj1) {
26855 {
26856 arg2 = (bool)(SWIG_As_bool(obj1));
26857 if (SWIG_arg_fail(2)) SWIG_fail;
26858 }
26859 }
26860 {
26861 PyThreadState* __tstate = wxPyBeginAllowThreads();
26862 result = (bool)(arg1)->Show(arg2);
26863
26864 wxPyEndAllowThreads(__tstate);
26865 if (PyErr_Occurred()) SWIG_fail;
26866 }
26867 {
26868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26869 }
26870 return resultobj;
26871 fail:
26872 return NULL;
26873 }
26874
26875
26876 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
26877 PyObject *resultobj;
26878 wxWindow *arg1 = (wxWindow *) 0 ;
26879 bool result;
26880 PyObject * obj0 = 0 ;
26881 char *kwnames[] = {
26882 (char *) "self", NULL
26883 };
26884
26885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
26886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26887 if (SWIG_arg_fail(1)) SWIG_fail;
26888 {
26889 PyThreadState* __tstate = wxPyBeginAllowThreads();
26890 result = (bool)(arg1)->Hide();
26891
26892 wxPyEndAllowThreads(__tstate);
26893 if (PyErr_Occurred()) SWIG_fail;
26894 }
26895 {
26896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26897 }
26898 return resultobj;
26899 fail:
26900 return NULL;
26901 }
26902
26903
26904 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
26905 PyObject *resultobj;
26906 wxWindow *arg1 = (wxWindow *) 0 ;
26907 bool arg2 = (bool) true ;
26908 bool result;
26909 PyObject * obj0 = 0 ;
26910 PyObject * obj1 = 0 ;
26911 char *kwnames[] = {
26912 (char *) "self",(char *) "enable", NULL
26913 };
26914
26915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
26916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26917 if (SWIG_arg_fail(1)) SWIG_fail;
26918 if (obj1) {
26919 {
26920 arg2 = (bool)(SWIG_As_bool(obj1));
26921 if (SWIG_arg_fail(2)) SWIG_fail;
26922 }
26923 }
26924 {
26925 PyThreadState* __tstate = wxPyBeginAllowThreads();
26926 result = (bool)(arg1)->Enable(arg2);
26927
26928 wxPyEndAllowThreads(__tstate);
26929 if (PyErr_Occurred()) SWIG_fail;
26930 }
26931 {
26932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26933 }
26934 return resultobj;
26935 fail:
26936 return NULL;
26937 }
26938
26939
26940 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
26941 PyObject *resultobj;
26942 wxWindow *arg1 = (wxWindow *) 0 ;
26943 bool result;
26944 PyObject * obj0 = 0 ;
26945 char *kwnames[] = {
26946 (char *) "self", NULL
26947 };
26948
26949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
26950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26951 if (SWIG_arg_fail(1)) SWIG_fail;
26952 {
26953 PyThreadState* __tstate = wxPyBeginAllowThreads();
26954 result = (bool)(arg1)->Disable();
26955
26956 wxPyEndAllowThreads(__tstate);
26957 if (PyErr_Occurred()) SWIG_fail;
26958 }
26959 {
26960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26961 }
26962 return resultobj;
26963 fail:
26964 return NULL;
26965 }
26966
26967
26968 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
26969 PyObject *resultobj;
26970 wxWindow *arg1 = (wxWindow *) 0 ;
26971 bool result;
26972 PyObject * obj0 = 0 ;
26973 char *kwnames[] = {
26974 (char *) "self", NULL
26975 };
26976
26977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
26978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26979 if (SWIG_arg_fail(1)) SWIG_fail;
26980 {
26981 PyThreadState* __tstate = wxPyBeginAllowThreads();
26982 result = (bool)((wxWindow const *)arg1)->IsShown();
26983
26984 wxPyEndAllowThreads(__tstate);
26985 if (PyErr_Occurred()) SWIG_fail;
26986 }
26987 {
26988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26989 }
26990 return resultobj;
26991 fail:
26992 return NULL;
26993 }
26994
26995
26996 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
26997 PyObject *resultobj;
26998 wxWindow *arg1 = (wxWindow *) 0 ;
26999 bool result;
27000 PyObject * obj0 = 0 ;
27001 char *kwnames[] = {
27002 (char *) "self", NULL
27003 };
27004
27005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27007 if (SWIG_arg_fail(1)) SWIG_fail;
27008 {
27009 PyThreadState* __tstate = wxPyBeginAllowThreads();
27010 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27011
27012 wxPyEndAllowThreads(__tstate);
27013 if (PyErr_Occurred()) SWIG_fail;
27014 }
27015 {
27016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27017 }
27018 return resultobj;
27019 fail:
27020 return NULL;
27021 }
27022
27023
27024 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27025 PyObject *resultobj;
27026 wxWindow *arg1 = (wxWindow *) 0 ;
27027 long arg2 ;
27028 PyObject * obj0 = 0 ;
27029 PyObject * obj1 = 0 ;
27030 char *kwnames[] = {
27031 (char *) "self",(char *) "style", NULL
27032 };
27033
27034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27036 if (SWIG_arg_fail(1)) SWIG_fail;
27037 {
27038 arg2 = (long)(SWIG_As_long(obj1));
27039 if (SWIG_arg_fail(2)) SWIG_fail;
27040 }
27041 {
27042 PyThreadState* __tstate = wxPyBeginAllowThreads();
27043 (arg1)->SetWindowStyleFlag(arg2);
27044
27045 wxPyEndAllowThreads(__tstate);
27046 if (PyErr_Occurred()) SWIG_fail;
27047 }
27048 Py_INCREF(Py_None); resultobj = Py_None;
27049 return resultobj;
27050 fail:
27051 return NULL;
27052 }
27053
27054
27055 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27056 PyObject *resultobj;
27057 wxWindow *arg1 = (wxWindow *) 0 ;
27058 long result;
27059 PyObject * obj0 = 0 ;
27060 char *kwnames[] = {
27061 (char *) "self", NULL
27062 };
27063
27064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27066 if (SWIG_arg_fail(1)) SWIG_fail;
27067 {
27068 PyThreadState* __tstate = wxPyBeginAllowThreads();
27069 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27070
27071 wxPyEndAllowThreads(__tstate);
27072 if (PyErr_Occurred()) SWIG_fail;
27073 }
27074 {
27075 resultobj = SWIG_From_long((long)(result));
27076 }
27077 return resultobj;
27078 fail:
27079 return NULL;
27080 }
27081
27082
27083 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27084 PyObject *resultobj;
27085 wxWindow *arg1 = (wxWindow *) 0 ;
27086 int arg2 ;
27087 bool result;
27088 PyObject * obj0 = 0 ;
27089 PyObject * obj1 = 0 ;
27090 char *kwnames[] = {
27091 (char *) "self",(char *) "flag", NULL
27092 };
27093
27094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27096 if (SWIG_arg_fail(1)) SWIG_fail;
27097 {
27098 arg2 = (int)(SWIG_As_int(obj1));
27099 if (SWIG_arg_fail(2)) SWIG_fail;
27100 }
27101 {
27102 PyThreadState* __tstate = wxPyBeginAllowThreads();
27103 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27104
27105 wxPyEndAllowThreads(__tstate);
27106 if (PyErr_Occurred()) SWIG_fail;
27107 }
27108 {
27109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27110 }
27111 return resultobj;
27112 fail:
27113 return NULL;
27114 }
27115
27116
27117 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27118 PyObject *resultobj;
27119 wxWindow *arg1 = (wxWindow *) 0 ;
27120 bool result;
27121 PyObject * obj0 = 0 ;
27122 char *kwnames[] = {
27123 (char *) "self", NULL
27124 };
27125
27126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27128 if (SWIG_arg_fail(1)) SWIG_fail;
27129 {
27130 PyThreadState* __tstate = wxPyBeginAllowThreads();
27131 result = (bool)((wxWindow const *)arg1)->IsRetained();
27132
27133 wxPyEndAllowThreads(__tstate);
27134 if (PyErr_Occurred()) SWIG_fail;
27135 }
27136 {
27137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27138 }
27139 return resultobj;
27140 fail:
27141 return NULL;
27142 }
27143
27144
27145 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27146 PyObject *resultobj;
27147 wxWindow *arg1 = (wxWindow *) 0 ;
27148 long arg2 ;
27149 PyObject * obj0 = 0 ;
27150 PyObject * obj1 = 0 ;
27151 char *kwnames[] = {
27152 (char *) "self",(char *) "exStyle", NULL
27153 };
27154
27155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27157 if (SWIG_arg_fail(1)) SWIG_fail;
27158 {
27159 arg2 = (long)(SWIG_As_long(obj1));
27160 if (SWIG_arg_fail(2)) SWIG_fail;
27161 }
27162 {
27163 PyThreadState* __tstate = wxPyBeginAllowThreads();
27164 (arg1)->SetExtraStyle(arg2);
27165
27166 wxPyEndAllowThreads(__tstate);
27167 if (PyErr_Occurred()) SWIG_fail;
27168 }
27169 Py_INCREF(Py_None); resultobj = Py_None;
27170 return resultobj;
27171 fail:
27172 return NULL;
27173 }
27174
27175
27176 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27177 PyObject *resultobj;
27178 wxWindow *arg1 = (wxWindow *) 0 ;
27179 long result;
27180 PyObject * obj0 = 0 ;
27181 char *kwnames[] = {
27182 (char *) "self", NULL
27183 };
27184
27185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27187 if (SWIG_arg_fail(1)) SWIG_fail;
27188 {
27189 PyThreadState* __tstate = wxPyBeginAllowThreads();
27190 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27191
27192 wxPyEndAllowThreads(__tstate);
27193 if (PyErr_Occurred()) SWIG_fail;
27194 }
27195 {
27196 resultobj = SWIG_From_long((long)(result));
27197 }
27198 return resultobj;
27199 fail:
27200 return NULL;
27201 }
27202
27203
27204 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27205 PyObject *resultobj;
27206 wxWindow *arg1 = (wxWindow *) 0 ;
27207 bool arg2 = (bool) true ;
27208 PyObject * obj0 = 0 ;
27209 PyObject * obj1 = 0 ;
27210 char *kwnames[] = {
27211 (char *) "self",(char *) "modal", NULL
27212 };
27213
27214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27216 if (SWIG_arg_fail(1)) SWIG_fail;
27217 if (obj1) {
27218 {
27219 arg2 = (bool)(SWIG_As_bool(obj1));
27220 if (SWIG_arg_fail(2)) SWIG_fail;
27221 }
27222 }
27223 {
27224 PyThreadState* __tstate = wxPyBeginAllowThreads();
27225 (arg1)->MakeModal(arg2);
27226
27227 wxPyEndAllowThreads(__tstate);
27228 if (PyErr_Occurred()) SWIG_fail;
27229 }
27230 Py_INCREF(Py_None); resultobj = Py_None;
27231 return resultobj;
27232 fail:
27233 return NULL;
27234 }
27235
27236
27237 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27238 PyObject *resultobj;
27239 wxWindow *arg1 = (wxWindow *) 0 ;
27240 bool arg2 ;
27241 PyObject * obj0 = 0 ;
27242 PyObject * obj1 = 0 ;
27243 char *kwnames[] = {
27244 (char *) "self",(char *) "enableTheme", NULL
27245 };
27246
27247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27249 if (SWIG_arg_fail(1)) SWIG_fail;
27250 {
27251 arg2 = (bool)(SWIG_As_bool(obj1));
27252 if (SWIG_arg_fail(2)) SWIG_fail;
27253 }
27254 {
27255 PyThreadState* __tstate = wxPyBeginAllowThreads();
27256 (arg1)->SetThemeEnabled(arg2);
27257
27258 wxPyEndAllowThreads(__tstate);
27259 if (PyErr_Occurred()) SWIG_fail;
27260 }
27261 Py_INCREF(Py_None); resultobj = Py_None;
27262 return resultobj;
27263 fail:
27264 return NULL;
27265 }
27266
27267
27268 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27269 PyObject *resultobj;
27270 wxWindow *arg1 = (wxWindow *) 0 ;
27271 bool result;
27272 PyObject * obj0 = 0 ;
27273 char *kwnames[] = {
27274 (char *) "self", NULL
27275 };
27276
27277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27279 if (SWIG_arg_fail(1)) SWIG_fail;
27280 {
27281 PyThreadState* __tstate = wxPyBeginAllowThreads();
27282 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27283
27284 wxPyEndAllowThreads(__tstate);
27285 if (PyErr_Occurred()) SWIG_fail;
27286 }
27287 {
27288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27289 }
27290 return resultobj;
27291 fail:
27292 return NULL;
27293 }
27294
27295
27296 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27297 PyObject *resultobj;
27298 wxWindow *arg1 = (wxWindow *) 0 ;
27299 PyObject * obj0 = 0 ;
27300 char *kwnames[] = {
27301 (char *) "self", NULL
27302 };
27303
27304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27306 if (SWIG_arg_fail(1)) SWIG_fail;
27307 {
27308 PyThreadState* __tstate = wxPyBeginAllowThreads();
27309 (arg1)->SetFocus();
27310
27311 wxPyEndAllowThreads(__tstate);
27312 if (PyErr_Occurred()) SWIG_fail;
27313 }
27314 Py_INCREF(Py_None); resultobj = Py_None;
27315 return resultobj;
27316 fail:
27317 return NULL;
27318 }
27319
27320
27321 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27322 PyObject *resultobj;
27323 wxWindow *arg1 = (wxWindow *) 0 ;
27324 PyObject * obj0 = 0 ;
27325 char *kwnames[] = {
27326 (char *) "self", NULL
27327 };
27328
27329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27331 if (SWIG_arg_fail(1)) SWIG_fail;
27332 {
27333 PyThreadState* __tstate = wxPyBeginAllowThreads();
27334 (arg1)->SetFocusFromKbd();
27335
27336 wxPyEndAllowThreads(__tstate);
27337 if (PyErr_Occurred()) SWIG_fail;
27338 }
27339 Py_INCREF(Py_None); resultobj = Py_None;
27340 return resultobj;
27341 fail:
27342 return NULL;
27343 }
27344
27345
27346 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27347 PyObject *resultobj;
27348 wxWindow *result;
27349 char *kwnames[] = {
27350 NULL
27351 };
27352
27353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27354 {
27355 if (!wxPyCheckForApp()) SWIG_fail;
27356 PyThreadState* __tstate = wxPyBeginAllowThreads();
27357 result = (wxWindow *)wxWindow::FindFocus();
27358
27359 wxPyEndAllowThreads(__tstate);
27360 if (PyErr_Occurred()) SWIG_fail;
27361 }
27362 {
27363 resultobj = wxPyMake_wxObject(result, 0);
27364 }
27365 return resultobj;
27366 fail:
27367 return NULL;
27368 }
27369
27370
27371 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27372 PyObject *resultobj;
27373 wxWindow *arg1 = (wxWindow *) 0 ;
27374 bool result;
27375 PyObject * obj0 = 0 ;
27376 char *kwnames[] = {
27377 (char *) "self", NULL
27378 };
27379
27380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27382 if (SWIG_arg_fail(1)) SWIG_fail;
27383 {
27384 PyThreadState* __tstate = wxPyBeginAllowThreads();
27385 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27386
27387 wxPyEndAllowThreads(__tstate);
27388 if (PyErr_Occurred()) SWIG_fail;
27389 }
27390 {
27391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27392 }
27393 return resultobj;
27394 fail:
27395 return NULL;
27396 }
27397
27398
27399 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27400 PyObject *resultobj;
27401 wxWindow *arg1 = (wxWindow *) 0 ;
27402 bool result;
27403 PyObject * obj0 = 0 ;
27404 char *kwnames[] = {
27405 (char *) "self", NULL
27406 };
27407
27408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27410 if (SWIG_arg_fail(1)) SWIG_fail;
27411 {
27412 PyThreadState* __tstate = wxPyBeginAllowThreads();
27413 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27414
27415 wxPyEndAllowThreads(__tstate);
27416 if (PyErr_Occurred()) SWIG_fail;
27417 }
27418 {
27419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27420 }
27421 return resultobj;
27422 fail:
27423 return NULL;
27424 }
27425
27426
27427 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27428 PyObject *resultobj;
27429 wxWindow *arg1 = (wxWindow *) 0 ;
27430 wxWindow *result;
27431 PyObject * obj0 = 0 ;
27432 char *kwnames[] = {
27433 (char *) "self", NULL
27434 };
27435
27436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27438 if (SWIG_arg_fail(1)) SWIG_fail;
27439 {
27440 PyThreadState* __tstate = wxPyBeginAllowThreads();
27441 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27442
27443 wxPyEndAllowThreads(__tstate);
27444 if (PyErr_Occurred()) SWIG_fail;
27445 }
27446 {
27447 resultobj = wxPyMake_wxObject(result, 0);
27448 }
27449 return resultobj;
27450 fail:
27451 return NULL;
27452 }
27453
27454
27455 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27456 PyObject *resultobj;
27457 wxWindow *arg1 = (wxWindow *) 0 ;
27458 wxWindow *arg2 = (wxWindow *) 0 ;
27459 wxWindow *result;
27460 PyObject * obj0 = 0 ;
27461 PyObject * obj1 = 0 ;
27462 char *kwnames[] = {
27463 (char *) "self",(char *) "child", NULL
27464 };
27465
27466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27468 if (SWIG_arg_fail(1)) SWIG_fail;
27469 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27470 if (SWIG_arg_fail(2)) SWIG_fail;
27471 {
27472 PyThreadState* __tstate = wxPyBeginAllowThreads();
27473 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27474
27475 wxPyEndAllowThreads(__tstate);
27476 if (PyErr_Occurred()) SWIG_fail;
27477 }
27478 {
27479 resultobj = wxPyMake_wxObject(result, 0);
27480 }
27481 return resultobj;
27482 fail:
27483 return NULL;
27484 }
27485
27486
27487 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27488 PyObject *resultobj;
27489 wxWindow *arg1 = (wxWindow *) 0 ;
27490 wxWindow *arg2 = (wxWindow *) 0 ;
27491 PyObject * obj0 = 0 ;
27492 PyObject * obj1 = 0 ;
27493 char *kwnames[] = {
27494 (char *) "self",(char *) "win", NULL
27495 };
27496
27497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27499 if (SWIG_arg_fail(1)) SWIG_fail;
27500 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27501 if (SWIG_arg_fail(2)) SWIG_fail;
27502 {
27503 PyThreadState* __tstate = wxPyBeginAllowThreads();
27504 (arg1)->SetTmpDefaultItem(arg2);
27505
27506 wxPyEndAllowThreads(__tstate);
27507 if (PyErr_Occurred()) SWIG_fail;
27508 }
27509 Py_INCREF(Py_None); resultobj = Py_None;
27510 return resultobj;
27511 fail:
27512 return NULL;
27513 }
27514
27515
27516 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27517 PyObject *resultobj;
27518 wxWindow *arg1 = (wxWindow *) 0 ;
27519 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27520 bool result;
27521 PyObject * obj0 = 0 ;
27522 PyObject * obj1 = 0 ;
27523 char *kwnames[] = {
27524 (char *) "self",(char *) "flags", NULL
27525 };
27526
27527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27529 if (SWIG_arg_fail(1)) SWIG_fail;
27530 if (obj1) {
27531 {
27532 arg2 = (int)(SWIG_As_int(obj1));
27533 if (SWIG_arg_fail(2)) SWIG_fail;
27534 }
27535 }
27536 {
27537 PyThreadState* __tstate = wxPyBeginAllowThreads();
27538 result = (bool)(arg1)->Navigate(arg2);
27539
27540 wxPyEndAllowThreads(__tstate);
27541 if (PyErr_Occurred()) SWIG_fail;
27542 }
27543 {
27544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27545 }
27546 return resultobj;
27547 fail:
27548 return NULL;
27549 }
27550
27551
27552 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27553 PyObject *resultobj;
27554 wxWindow *arg1 = (wxWindow *) 0 ;
27555 wxWindow *arg2 = (wxWindow *) 0 ;
27556 PyObject * obj0 = 0 ;
27557 PyObject * obj1 = 0 ;
27558 char *kwnames[] = {
27559 (char *) "self",(char *) "win", NULL
27560 };
27561
27562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27564 if (SWIG_arg_fail(1)) SWIG_fail;
27565 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27566 if (SWIG_arg_fail(2)) SWIG_fail;
27567 {
27568 PyThreadState* __tstate = wxPyBeginAllowThreads();
27569 (arg1)->MoveAfterInTabOrder(arg2);
27570
27571 wxPyEndAllowThreads(__tstate);
27572 if (PyErr_Occurred()) SWIG_fail;
27573 }
27574 Py_INCREF(Py_None); resultobj = Py_None;
27575 return resultobj;
27576 fail:
27577 return NULL;
27578 }
27579
27580
27581 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27582 PyObject *resultobj;
27583 wxWindow *arg1 = (wxWindow *) 0 ;
27584 wxWindow *arg2 = (wxWindow *) 0 ;
27585 PyObject * obj0 = 0 ;
27586 PyObject * obj1 = 0 ;
27587 char *kwnames[] = {
27588 (char *) "self",(char *) "win", NULL
27589 };
27590
27591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27593 if (SWIG_arg_fail(1)) SWIG_fail;
27594 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27595 if (SWIG_arg_fail(2)) SWIG_fail;
27596 {
27597 PyThreadState* __tstate = wxPyBeginAllowThreads();
27598 (arg1)->MoveBeforeInTabOrder(arg2);
27599
27600 wxPyEndAllowThreads(__tstate);
27601 if (PyErr_Occurred()) SWIG_fail;
27602 }
27603 Py_INCREF(Py_None); resultobj = Py_None;
27604 return resultobj;
27605 fail:
27606 return NULL;
27607 }
27608
27609
27610 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27611 PyObject *resultobj;
27612 wxWindow *arg1 = (wxWindow *) 0 ;
27613 PyObject *result;
27614 PyObject * obj0 = 0 ;
27615 char *kwnames[] = {
27616 (char *) "self", NULL
27617 };
27618
27619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27621 if (SWIG_arg_fail(1)) SWIG_fail;
27622 {
27623 PyThreadState* __tstate = wxPyBeginAllowThreads();
27624 result = (PyObject *)wxWindow_GetChildren(arg1);
27625
27626 wxPyEndAllowThreads(__tstate);
27627 if (PyErr_Occurred()) SWIG_fail;
27628 }
27629 resultobj = result;
27630 return resultobj;
27631 fail:
27632 return NULL;
27633 }
27634
27635
27636 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27637 PyObject *resultobj;
27638 wxWindow *arg1 = (wxWindow *) 0 ;
27639 wxWindow *result;
27640 PyObject * obj0 = 0 ;
27641 char *kwnames[] = {
27642 (char *) "self", NULL
27643 };
27644
27645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27647 if (SWIG_arg_fail(1)) SWIG_fail;
27648 {
27649 PyThreadState* __tstate = wxPyBeginAllowThreads();
27650 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27651
27652 wxPyEndAllowThreads(__tstate);
27653 if (PyErr_Occurred()) SWIG_fail;
27654 }
27655 {
27656 resultobj = wxPyMake_wxObject(result, 0);
27657 }
27658 return resultobj;
27659 fail:
27660 return NULL;
27661 }
27662
27663
27664 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27665 PyObject *resultobj;
27666 wxWindow *arg1 = (wxWindow *) 0 ;
27667 wxWindow *result;
27668 PyObject * obj0 = 0 ;
27669 char *kwnames[] = {
27670 (char *) "self", NULL
27671 };
27672
27673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27675 if (SWIG_arg_fail(1)) SWIG_fail;
27676 {
27677 PyThreadState* __tstate = wxPyBeginAllowThreads();
27678 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27679
27680 wxPyEndAllowThreads(__tstate);
27681 if (PyErr_Occurred()) SWIG_fail;
27682 }
27683 {
27684 resultobj = wxPyMake_wxObject(result, 0);
27685 }
27686 return resultobj;
27687 fail:
27688 return NULL;
27689 }
27690
27691
27692 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27693 PyObject *resultobj;
27694 wxWindow *arg1 = (wxWindow *) 0 ;
27695 bool result;
27696 PyObject * obj0 = 0 ;
27697 char *kwnames[] = {
27698 (char *) "self", NULL
27699 };
27700
27701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27703 if (SWIG_arg_fail(1)) SWIG_fail;
27704 {
27705 PyThreadState* __tstate = wxPyBeginAllowThreads();
27706 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
27707
27708 wxPyEndAllowThreads(__tstate);
27709 if (PyErr_Occurred()) SWIG_fail;
27710 }
27711 {
27712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27713 }
27714 return resultobj;
27715 fail:
27716 return NULL;
27717 }
27718
27719
27720 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
27721 PyObject *resultobj;
27722 wxWindow *arg1 = (wxWindow *) 0 ;
27723 wxWindow *arg2 = (wxWindow *) 0 ;
27724 bool result;
27725 PyObject * obj0 = 0 ;
27726 PyObject * obj1 = 0 ;
27727 char *kwnames[] = {
27728 (char *) "self",(char *) "newParent", NULL
27729 };
27730
27731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
27732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27733 if (SWIG_arg_fail(1)) SWIG_fail;
27734 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27735 if (SWIG_arg_fail(2)) SWIG_fail;
27736 {
27737 PyThreadState* __tstate = wxPyBeginAllowThreads();
27738 result = (bool)(arg1)->Reparent(arg2);
27739
27740 wxPyEndAllowThreads(__tstate);
27741 if (PyErr_Occurred()) SWIG_fail;
27742 }
27743 {
27744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27745 }
27746 return resultobj;
27747 fail:
27748 return NULL;
27749 }
27750
27751
27752 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
27753 PyObject *resultobj;
27754 wxWindow *arg1 = (wxWindow *) 0 ;
27755 wxWindow *arg2 = (wxWindow *) 0 ;
27756 PyObject * obj0 = 0 ;
27757 PyObject * obj1 = 0 ;
27758 char *kwnames[] = {
27759 (char *) "self",(char *) "child", NULL
27760 };
27761
27762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
27763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27764 if (SWIG_arg_fail(1)) SWIG_fail;
27765 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27766 if (SWIG_arg_fail(2)) SWIG_fail;
27767 {
27768 PyThreadState* __tstate = wxPyBeginAllowThreads();
27769 (arg1)->AddChild(arg2);
27770
27771 wxPyEndAllowThreads(__tstate);
27772 if (PyErr_Occurred()) SWIG_fail;
27773 }
27774 Py_INCREF(Py_None); resultobj = Py_None;
27775 return resultobj;
27776 fail:
27777 return NULL;
27778 }
27779
27780
27781 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
27782 PyObject *resultobj;
27783 wxWindow *arg1 = (wxWindow *) 0 ;
27784 wxWindow *arg2 = (wxWindow *) 0 ;
27785 PyObject * obj0 = 0 ;
27786 PyObject * obj1 = 0 ;
27787 char *kwnames[] = {
27788 (char *) "self",(char *) "child", NULL
27789 };
27790
27791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
27792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27793 if (SWIG_arg_fail(1)) SWIG_fail;
27794 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27795 if (SWIG_arg_fail(2)) SWIG_fail;
27796 {
27797 PyThreadState* __tstate = wxPyBeginAllowThreads();
27798 (arg1)->RemoveChild(arg2);
27799
27800 wxPyEndAllowThreads(__tstate);
27801 if (PyErr_Occurred()) SWIG_fail;
27802 }
27803 Py_INCREF(Py_None); resultobj = Py_None;
27804 return resultobj;
27805 fail:
27806 return NULL;
27807 }
27808
27809
27810 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
27811 PyObject *resultobj;
27812 wxWindow *arg1 = (wxWindow *) 0 ;
27813 long arg2 ;
27814 wxWindow *result;
27815 PyObject * obj0 = 0 ;
27816 PyObject * obj1 = 0 ;
27817 char *kwnames[] = {
27818 (char *) "self",(char *) "winid", NULL
27819 };
27820
27821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",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 arg2 = (long)(SWIG_As_long(obj1));
27826 if (SWIG_arg_fail(2)) SWIG_fail;
27827 }
27828 {
27829 PyThreadState* __tstate = wxPyBeginAllowThreads();
27830 result = (wxWindow *)(arg1)->FindWindow(arg2);
27831
27832 wxPyEndAllowThreads(__tstate);
27833 if (PyErr_Occurred()) SWIG_fail;
27834 }
27835 {
27836 resultobj = wxPyMake_wxObject(result, 0);
27837 }
27838 return resultobj;
27839 fail:
27840 return NULL;
27841 }
27842
27843
27844 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
27845 PyObject *resultobj;
27846 wxWindow *arg1 = (wxWindow *) 0 ;
27847 wxString *arg2 = 0 ;
27848 wxWindow *result;
27849 bool temp2 = false ;
27850 PyObject * obj0 = 0 ;
27851 PyObject * obj1 = 0 ;
27852 char *kwnames[] = {
27853 (char *) "self",(char *) "name", NULL
27854 };
27855
27856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
27857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27858 if (SWIG_arg_fail(1)) SWIG_fail;
27859 {
27860 arg2 = wxString_in_helper(obj1);
27861 if (arg2 == NULL) SWIG_fail;
27862 temp2 = true;
27863 }
27864 {
27865 PyThreadState* __tstate = wxPyBeginAllowThreads();
27866 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
27867
27868 wxPyEndAllowThreads(__tstate);
27869 if (PyErr_Occurred()) SWIG_fail;
27870 }
27871 {
27872 resultobj = wxPyMake_wxObject(result, 0);
27873 }
27874 {
27875 if (temp2)
27876 delete arg2;
27877 }
27878 return resultobj;
27879 fail:
27880 {
27881 if (temp2)
27882 delete arg2;
27883 }
27884 return NULL;
27885 }
27886
27887
27888 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27889 PyObject *resultobj;
27890 wxWindow *arg1 = (wxWindow *) 0 ;
27891 wxEvtHandler *result;
27892 PyObject * obj0 = 0 ;
27893 char *kwnames[] = {
27894 (char *) "self", NULL
27895 };
27896
27897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
27898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27899 if (SWIG_arg_fail(1)) SWIG_fail;
27900 {
27901 PyThreadState* __tstate = wxPyBeginAllowThreads();
27902 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
27903
27904 wxPyEndAllowThreads(__tstate);
27905 if (PyErr_Occurred()) SWIG_fail;
27906 }
27907 {
27908 resultobj = wxPyMake_wxObject(result, 0);
27909 }
27910 return resultobj;
27911 fail:
27912 return NULL;
27913 }
27914
27915
27916 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27917 PyObject *resultobj;
27918 wxWindow *arg1 = (wxWindow *) 0 ;
27919 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27920 PyObject * obj0 = 0 ;
27921 PyObject * obj1 = 0 ;
27922 char *kwnames[] = {
27923 (char *) "self",(char *) "handler", NULL
27924 };
27925
27926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
27927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27928 if (SWIG_arg_fail(1)) SWIG_fail;
27929 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27930 if (SWIG_arg_fail(2)) SWIG_fail;
27931 {
27932 PyThreadState* __tstate = wxPyBeginAllowThreads();
27933 (arg1)->SetEventHandler(arg2);
27934
27935 wxPyEndAllowThreads(__tstate);
27936 if (PyErr_Occurred()) SWIG_fail;
27937 }
27938 Py_INCREF(Py_None); resultobj = Py_None;
27939 return resultobj;
27940 fail:
27941 return NULL;
27942 }
27943
27944
27945 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27946 PyObject *resultobj;
27947 wxWindow *arg1 = (wxWindow *) 0 ;
27948 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27949 PyObject * obj0 = 0 ;
27950 PyObject * obj1 = 0 ;
27951 char *kwnames[] = {
27952 (char *) "self",(char *) "handler", NULL
27953 };
27954
27955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
27956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27957 if (SWIG_arg_fail(1)) SWIG_fail;
27958 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27959 if (SWIG_arg_fail(2)) SWIG_fail;
27960 {
27961 PyThreadState* __tstate = wxPyBeginAllowThreads();
27962 (arg1)->PushEventHandler(arg2);
27963
27964 wxPyEndAllowThreads(__tstate);
27965 if (PyErr_Occurred()) SWIG_fail;
27966 }
27967 Py_INCREF(Py_None); resultobj = Py_None;
27968 return resultobj;
27969 fail:
27970 return NULL;
27971 }
27972
27973
27974 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27975 PyObject *resultobj;
27976 wxWindow *arg1 = (wxWindow *) 0 ;
27977 bool arg2 = (bool) false ;
27978 wxEvtHandler *result;
27979 PyObject * obj0 = 0 ;
27980 PyObject * obj1 = 0 ;
27981 char *kwnames[] = {
27982 (char *) "self",(char *) "deleteHandler", NULL
27983 };
27984
27985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
27986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27987 if (SWIG_arg_fail(1)) SWIG_fail;
27988 if (obj1) {
27989 {
27990 arg2 = (bool)(SWIG_As_bool(obj1));
27991 if (SWIG_arg_fail(2)) SWIG_fail;
27992 }
27993 }
27994 {
27995 PyThreadState* __tstate = wxPyBeginAllowThreads();
27996 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
27997
27998 wxPyEndAllowThreads(__tstate);
27999 if (PyErr_Occurred()) SWIG_fail;
28000 }
28001 {
28002 resultobj = wxPyMake_wxObject(result, 0);
28003 }
28004 return resultobj;
28005 fail:
28006 return NULL;
28007 }
28008
28009
28010 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28011 PyObject *resultobj;
28012 wxWindow *arg1 = (wxWindow *) 0 ;
28013 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28014 bool result;
28015 PyObject * obj0 = 0 ;
28016 PyObject * obj1 = 0 ;
28017 char *kwnames[] = {
28018 (char *) "self",(char *) "handler", NULL
28019 };
28020
28021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28023 if (SWIG_arg_fail(1)) SWIG_fail;
28024 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28025 if (SWIG_arg_fail(2)) SWIG_fail;
28026 {
28027 PyThreadState* __tstate = wxPyBeginAllowThreads();
28028 result = (bool)(arg1)->RemoveEventHandler(arg2);
28029
28030 wxPyEndAllowThreads(__tstate);
28031 if (PyErr_Occurred()) SWIG_fail;
28032 }
28033 {
28034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28035 }
28036 return resultobj;
28037 fail:
28038 return NULL;
28039 }
28040
28041
28042 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28043 PyObject *resultobj;
28044 wxWindow *arg1 = (wxWindow *) 0 ;
28045 wxValidator *arg2 = 0 ;
28046 PyObject * obj0 = 0 ;
28047 PyObject * obj1 = 0 ;
28048 char *kwnames[] = {
28049 (char *) "self",(char *) "validator", NULL
28050 };
28051
28052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28054 if (SWIG_arg_fail(1)) SWIG_fail;
28055 {
28056 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28057 if (SWIG_arg_fail(2)) SWIG_fail;
28058 if (arg2 == NULL) {
28059 SWIG_null_ref("wxValidator");
28060 }
28061 if (SWIG_arg_fail(2)) SWIG_fail;
28062 }
28063 {
28064 PyThreadState* __tstate = wxPyBeginAllowThreads();
28065 (arg1)->SetValidator((wxValidator const &)*arg2);
28066
28067 wxPyEndAllowThreads(__tstate);
28068 if (PyErr_Occurred()) SWIG_fail;
28069 }
28070 Py_INCREF(Py_None); resultobj = Py_None;
28071 return resultobj;
28072 fail:
28073 return NULL;
28074 }
28075
28076
28077 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28078 PyObject *resultobj;
28079 wxWindow *arg1 = (wxWindow *) 0 ;
28080 wxValidator *result;
28081 PyObject * obj0 = 0 ;
28082 char *kwnames[] = {
28083 (char *) "self", NULL
28084 };
28085
28086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28088 if (SWIG_arg_fail(1)) SWIG_fail;
28089 {
28090 PyThreadState* __tstate = wxPyBeginAllowThreads();
28091 result = (wxValidator *)(arg1)->GetValidator();
28092
28093 wxPyEndAllowThreads(__tstate);
28094 if (PyErr_Occurred()) SWIG_fail;
28095 }
28096 {
28097 resultobj = wxPyMake_wxObject(result, 0);
28098 }
28099 return resultobj;
28100 fail:
28101 return NULL;
28102 }
28103
28104
28105 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28106 PyObject *resultobj;
28107 wxWindow *arg1 = (wxWindow *) 0 ;
28108 bool result;
28109 PyObject * obj0 = 0 ;
28110 char *kwnames[] = {
28111 (char *) "self", NULL
28112 };
28113
28114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28116 if (SWIG_arg_fail(1)) SWIG_fail;
28117 {
28118 PyThreadState* __tstate = wxPyBeginAllowThreads();
28119 result = (bool)(arg1)->Validate();
28120
28121 wxPyEndAllowThreads(__tstate);
28122 if (PyErr_Occurred()) SWIG_fail;
28123 }
28124 {
28125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28126 }
28127 return resultobj;
28128 fail:
28129 return NULL;
28130 }
28131
28132
28133 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28134 PyObject *resultobj;
28135 wxWindow *arg1 = (wxWindow *) 0 ;
28136 bool result;
28137 PyObject * obj0 = 0 ;
28138 char *kwnames[] = {
28139 (char *) "self", NULL
28140 };
28141
28142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28144 if (SWIG_arg_fail(1)) SWIG_fail;
28145 {
28146 PyThreadState* __tstate = wxPyBeginAllowThreads();
28147 result = (bool)(arg1)->TransferDataToWindow();
28148
28149 wxPyEndAllowThreads(__tstate);
28150 if (PyErr_Occurred()) SWIG_fail;
28151 }
28152 {
28153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28154 }
28155 return resultobj;
28156 fail:
28157 return NULL;
28158 }
28159
28160
28161 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28162 PyObject *resultobj;
28163 wxWindow *arg1 = (wxWindow *) 0 ;
28164 bool result;
28165 PyObject * obj0 = 0 ;
28166 char *kwnames[] = {
28167 (char *) "self", NULL
28168 };
28169
28170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28172 if (SWIG_arg_fail(1)) SWIG_fail;
28173 {
28174 PyThreadState* __tstate = wxPyBeginAllowThreads();
28175 result = (bool)(arg1)->TransferDataFromWindow();
28176
28177 wxPyEndAllowThreads(__tstate);
28178 if (PyErr_Occurred()) SWIG_fail;
28179 }
28180 {
28181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28182 }
28183 return resultobj;
28184 fail:
28185 return NULL;
28186 }
28187
28188
28189 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28190 PyObject *resultobj;
28191 wxWindow *arg1 = (wxWindow *) 0 ;
28192 PyObject * obj0 = 0 ;
28193 char *kwnames[] = {
28194 (char *) "self", NULL
28195 };
28196
28197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28199 if (SWIG_arg_fail(1)) SWIG_fail;
28200 {
28201 PyThreadState* __tstate = wxPyBeginAllowThreads();
28202 (arg1)->InitDialog();
28203
28204 wxPyEndAllowThreads(__tstate);
28205 if (PyErr_Occurred()) SWIG_fail;
28206 }
28207 Py_INCREF(Py_None); resultobj = Py_None;
28208 return resultobj;
28209 fail:
28210 return NULL;
28211 }
28212
28213
28214 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28215 PyObject *resultobj;
28216 wxWindow *arg1 = (wxWindow *) 0 ;
28217 wxAcceleratorTable *arg2 = 0 ;
28218 PyObject * obj0 = 0 ;
28219 PyObject * obj1 = 0 ;
28220 char *kwnames[] = {
28221 (char *) "self",(char *) "accel", NULL
28222 };
28223
28224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28226 if (SWIG_arg_fail(1)) SWIG_fail;
28227 {
28228 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28229 if (SWIG_arg_fail(2)) SWIG_fail;
28230 if (arg2 == NULL) {
28231 SWIG_null_ref("wxAcceleratorTable");
28232 }
28233 if (SWIG_arg_fail(2)) SWIG_fail;
28234 }
28235 {
28236 PyThreadState* __tstate = wxPyBeginAllowThreads();
28237 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28238
28239 wxPyEndAllowThreads(__tstate);
28240 if (PyErr_Occurred()) SWIG_fail;
28241 }
28242 Py_INCREF(Py_None); resultobj = Py_None;
28243 return resultobj;
28244 fail:
28245 return NULL;
28246 }
28247
28248
28249 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28250 PyObject *resultobj;
28251 wxWindow *arg1 = (wxWindow *) 0 ;
28252 wxAcceleratorTable *result;
28253 PyObject * obj0 = 0 ;
28254 char *kwnames[] = {
28255 (char *) "self", NULL
28256 };
28257
28258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28260 if (SWIG_arg_fail(1)) SWIG_fail;
28261 {
28262 PyThreadState* __tstate = wxPyBeginAllowThreads();
28263 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28264
28265 wxPyEndAllowThreads(__tstate);
28266 if (PyErr_Occurred()) SWIG_fail;
28267 }
28268 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28269 return resultobj;
28270 fail:
28271 return NULL;
28272 }
28273
28274
28275 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28276 PyObject *resultobj;
28277 wxWindow *arg1 = (wxWindow *) 0 ;
28278 int arg2 ;
28279 int arg3 ;
28280 int arg4 ;
28281 bool result;
28282 PyObject * obj0 = 0 ;
28283 PyObject * obj1 = 0 ;
28284 PyObject * obj2 = 0 ;
28285 PyObject * obj3 = 0 ;
28286 char *kwnames[] = {
28287 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28288 };
28289
28290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28292 if (SWIG_arg_fail(1)) SWIG_fail;
28293 {
28294 arg2 = (int)(SWIG_As_int(obj1));
28295 if (SWIG_arg_fail(2)) SWIG_fail;
28296 }
28297 {
28298 arg3 = (int)(SWIG_As_int(obj2));
28299 if (SWIG_arg_fail(3)) SWIG_fail;
28300 }
28301 {
28302 arg4 = (int)(SWIG_As_int(obj3));
28303 if (SWIG_arg_fail(4)) SWIG_fail;
28304 }
28305 {
28306 PyThreadState* __tstate = wxPyBeginAllowThreads();
28307 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28308
28309 wxPyEndAllowThreads(__tstate);
28310 if (PyErr_Occurred()) SWIG_fail;
28311 }
28312 {
28313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28314 }
28315 return resultobj;
28316 fail:
28317 return NULL;
28318 }
28319
28320
28321 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28322 PyObject *resultobj;
28323 wxWindow *arg1 = (wxWindow *) 0 ;
28324 int arg2 ;
28325 bool result;
28326 PyObject * obj0 = 0 ;
28327 PyObject * obj1 = 0 ;
28328 char *kwnames[] = {
28329 (char *) "self",(char *) "hotkeyId", NULL
28330 };
28331
28332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28334 if (SWIG_arg_fail(1)) SWIG_fail;
28335 {
28336 arg2 = (int)(SWIG_As_int(obj1));
28337 if (SWIG_arg_fail(2)) SWIG_fail;
28338 }
28339 {
28340 PyThreadState* __tstate = wxPyBeginAllowThreads();
28341 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28342
28343 wxPyEndAllowThreads(__tstate);
28344 if (PyErr_Occurred()) SWIG_fail;
28345 }
28346 {
28347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28348 }
28349 return resultobj;
28350 fail:
28351 return NULL;
28352 }
28353
28354
28355 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28356 PyObject *resultobj;
28357 wxWindow *arg1 = (wxWindow *) 0 ;
28358 wxPoint *arg2 = 0 ;
28359 wxPoint result;
28360 wxPoint temp2 ;
28361 PyObject * obj0 = 0 ;
28362 PyObject * obj1 = 0 ;
28363 char *kwnames[] = {
28364 (char *) "self",(char *) "pt", NULL
28365 };
28366
28367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28369 if (SWIG_arg_fail(1)) SWIG_fail;
28370 {
28371 arg2 = &temp2;
28372 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28373 }
28374 {
28375 PyThreadState* __tstate = wxPyBeginAllowThreads();
28376 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28377
28378 wxPyEndAllowThreads(__tstate);
28379 if (PyErr_Occurred()) SWIG_fail;
28380 }
28381 {
28382 wxPoint * resultptr;
28383 resultptr = new wxPoint((wxPoint &)(result));
28384 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28385 }
28386 return resultobj;
28387 fail:
28388 return NULL;
28389 }
28390
28391
28392 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28393 PyObject *resultobj;
28394 wxWindow *arg1 = (wxWindow *) 0 ;
28395 wxSize *arg2 = 0 ;
28396 wxSize result;
28397 wxSize temp2 ;
28398 PyObject * obj0 = 0 ;
28399 PyObject * obj1 = 0 ;
28400 char *kwnames[] = {
28401 (char *) "self",(char *) "sz", NULL
28402 };
28403
28404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28406 if (SWIG_arg_fail(1)) SWIG_fail;
28407 {
28408 arg2 = &temp2;
28409 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28410 }
28411 {
28412 PyThreadState* __tstate = wxPyBeginAllowThreads();
28413 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28414
28415 wxPyEndAllowThreads(__tstate);
28416 if (PyErr_Occurred()) SWIG_fail;
28417 }
28418 {
28419 wxSize * resultptr;
28420 resultptr = new wxSize((wxSize &)(result));
28421 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28422 }
28423 return resultobj;
28424 fail:
28425 return NULL;
28426 }
28427
28428
28429 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28430 PyObject *resultobj;
28431 wxWindow *arg1 = (wxWindow *) 0 ;
28432 wxPoint *arg2 = 0 ;
28433 wxPoint result;
28434 wxPoint temp2 ;
28435 PyObject * obj0 = 0 ;
28436 PyObject * obj1 = 0 ;
28437 char *kwnames[] = {
28438 (char *) "self",(char *) "pt", NULL
28439 };
28440
28441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28443 if (SWIG_arg_fail(1)) SWIG_fail;
28444 {
28445 arg2 = &temp2;
28446 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28447 }
28448 {
28449 PyThreadState* __tstate = wxPyBeginAllowThreads();
28450 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28451
28452 wxPyEndAllowThreads(__tstate);
28453 if (PyErr_Occurred()) SWIG_fail;
28454 }
28455 {
28456 wxPoint * resultptr;
28457 resultptr = new wxPoint((wxPoint &)(result));
28458 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28459 }
28460 return resultobj;
28461 fail:
28462 return NULL;
28463 }
28464
28465
28466 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28467 PyObject *resultobj;
28468 wxWindow *arg1 = (wxWindow *) 0 ;
28469 wxSize *arg2 = 0 ;
28470 wxSize result;
28471 wxSize temp2 ;
28472 PyObject * obj0 = 0 ;
28473 PyObject * obj1 = 0 ;
28474 char *kwnames[] = {
28475 (char *) "self",(char *) "sz", NULL
28476 };
28477
28478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28480 if (SWIG_arg_fail(1)) SWIG_fail;
28481 {
28482 arg2 = &temp2;
28483 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28484 }
28485 {
28486 PyThreadState* __tstate = wxPyBeginAllowThreads();
28487 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28488
28489 wxPyEndAllowThreads(__tstate);
28490 if (PyErr_Occurred()) SWIG_fail;
28491 }
28492 {
28493 wxSize * resultptr;
28494 resultptr = new wxSize((wxSize &)(result));
28495 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28496 }
28497 return resultobj;
28498 fail:
28499 return NULL;
28500 }
28501
28502
28503 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28504 PyObject *resultobj;
28505 wxWindow *arg1 = (wxWindow *) 0 ;
28506 wxPoint *arg2 = 0 ;
28507 wxPoint result;
28508 wxPoint temp2 ;
28509 PyObject * obj0 = 0 ;
28510 PyObject * obj1 = 0 ;
28511 char *kwnames[] = {
28512 (char *) "self",(char *) "pt", NULL
28513 };
28514
28515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28517 if (SWIG_arg_fail(1)) SWIG_fail;
28518 {
28519 arg2 = &temp2;
28520 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28521 }
28522 {
28523 PyThreadState* __tstate = wxPyBeginAllowThreads();
28524 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28525
28526 wxPyEndAllowThreads(__tstate);
28527 if (PyErr_Occurred()) SWIG_fail;
28528 }
28529 {
28530 wxPoint * resultptr;
28531 resultptr = new wxPoint((wxPoint &)(result));
28532 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28533 }
28534 return resultobj;
28535 fail:
28536 return NULL;
28537 }
28538
28539
28540 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28541 PyObject *resultobj;
28542 wxWindow *arg1 = (wxWindow *) 0 ;
28543 wxSize *arg2 = 0 ;
28544 wxSize result;
28545 wxSize temp2 ;
28546 PyObject * obj0 = 0 ;
28547 PyObject * obj1 = 0 ;
28548 char *kwnames[] = {
28549 (char *) "self",(char *) "sz", NULL
28550 };
28551
28552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
28553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28554 if (SWIG_arg_fail(1)) SWIG_fail;
28555 {
28556 arg2 = &temp2;
28557 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28558 }
28559 {
28560 PyThreadState* __tstate = wxPyBeginAllowThreads();
28561 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28562
28563 wxPyEndAllowThreads(__tstate);
28564 if (PyErr_Occurred()) SWIG_fail;
28565 }
28566 {
28567 wxSize * resultptr;
28568 resultptr = new wxSize((wxSize &)(result));
28569 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28570 }
28571 return resultobj;
28572 fail:
28573 return NULL;
28574 }
28575
28576
28577 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28578 PyObject *resultobj;
28579 wxWindow *arg1 = (wxWindow *) 0 ;
28580 int arg2 ;
28581 int arg3 ;
28582 PyObject * obj0 = 0 ;
28583 PyObject * obj1 = 0 ;
28584 PyObject * obj2 = 0 ;
28585 char *kwnames[] = {
28586 (char *) "self",(char *) "x",(char *) "y", NULL
28587 };
28588
28589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28591 if (SWIG_arg_fail(1)) SWIG_fail;
28592 {
28593 arg2 = (int)(SWIG_As_int(obj1));
28594 if (SWIG_arg_fail(2)) SWIG_fail;
28595 }
28596 {
28597 arg3 = (int)(SWIG_As_int(obj2));
28598 if (SWIG_arg_fail(3)) SWIG_fail;
28599 }
28600 {
28601 PyThreadState* __tstate = wxPyBeginAllowThreads();
28602 (arg1)->WarpPointer(arg2,arg3);
28603
28604 wxPyEndAllowThreads(__tstate);
28605 if (PyErr_Occurred()) SWIG_fail;
28606 }
28607 Py_INCREF(Py_None); resultobj = Py_None;
28608 return resultobj;
28609 fail:
28610 return NULL;
28611 }
28612
28613
28614 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28615 PyObject *resultobj;
28616 wxWindow *arg1 = (wxWindow *) 0 ;
28617 PyObject * obj0 = 0 ;
28618 char *kwnames[] = {
28619 (char *) "self", NULL
28620 };
28621
28622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28624 if (SWIG_arg_fail(1)) SWIG_fail;
28625 {
28626 PyThreadState* __tstate = wxPyBeginAllowThreads();
28627 (arg1)->CaptureMouse();
28628
28629 wxPyEndAllowThreads(__tstate);
28630 if (PyErr_Occurred()) SWIG_fail;
28631 }
28632 Py_INCREF(Py_None); resultobj = Py_None;
28633 return resultobj;
28634 fail:
28635 return NULL;
28636 }
28637
28638
28639 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28640 PyObject *resultobj;
28641 wxWindow *arg1 = (wxWindow *) 0 ;
28642 PyObject * obj0 = 0 ;
28643 char *kwnames[] = {
28644 (char *) "self", NULL
28645 };
28646
28647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28649 if (SWIG_arg_fail(1)) SWIG_fail;
28650 {
28651 PyThreadState* __tstate = wxPyBeginAllowThreads();
28652 (arg1)->ReleaseMouse();
28653
28654 wxPyEndAllowThreads(__tstate);
28655 if (PyErr_Occurred()) SWIG_fail;
28656 }
28657 Py_INCREF(Py_None); resultobj = Py_None;
28658 return resultobj;
28659 fail:
28660 return NULL;
28661 }
28662
28663
28664 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28665 PyObject *resultobj;
28666 wxWindow *result;
28667 char *kwnames[] = {
28668 NULL
28669 };
28670
28671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28672 {
28673 if (!wxPyCheckForApp()) SWIG_fail;
28674 PyThreadState* __tstate = wxPyBeginAllowThreads();
28675 result = (wxWindow *)wxWindow::GetCapture();
28676
28677 wxPyEndAllowThreads(__tstate);
28678 if (PyErr_Occurred()) SWIG_fail;
28679 }
28680 {
28681 resultobj = wxPyMake_wxObject(result, 0);
28682 }
28683 return resultobj;
28684 fail:
28685 return NULL;
28686 }
28687
28688
28689 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28690 PyObject *resultobj;
28691 wxWindow *arg1 = (wxWindow *) 0 ;
28692 bool result;
28693 PyObject * obj0 = 0 ;
28694 char *kwnames[] = {
28695 (char *) "self", NULL
28696 };
28697
28698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28700 if (SWIG_arg_fail(1)) SWIG_fail;
28701 {
28702 PyThreadState* __tstate = wxPyBeginAllowThreads();
28703 result = (bool)((wxWindow const *)arg1)->HasCapture();
28704
28705 wxPyEndAllowThreads(__tstate);
28706 if (PyErr_Occurred()) SWIG_fail;
28707 }
28708 {
28709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28710 }
28711 return resultobj;
28712 fail:
28713 return NULL;
28714 }
28715
28716
28717 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
28718 PyObject *resultobj;
28719 wxWindow *arg1 = (wxWindow *) 0 ;
28720 bool arg2 = (bool) true ;
28721 wxRect *arg3 = (wxRect *) NULL ;
28722 PyObject * obj0 = 0 ;
28723 PyObject * obj1 = 0 ;
28724 PyObject * obj2 = 0 ;
28725 char *kwnames[] = {
28726 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
28727 };
28728
28729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
28730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28731 if (SWIG_arg_fail(1)) SWIG_fail;
28732 if (obj1) {
28733 {
28734 arg2 = (bool)(SWIG_As_bool(obj1));
28735 if (SWIG_arg_fail(2)) SWIG_fail;
28736 }
28737 }
28738 if (obj2) {
28739 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
28740 if (SWIG_arg_fail(3)) SWIG_fail;
28741 }
28742 {
28743 PyThreadState* __tstate = wxPyBeginAllowThreads();
28744 (arg1)->Refresh(arg2,(wxRect const *)arg3);
28745
28746 wxPyEndAllowThreads(__tstate);
28747 if (PyErr_Occurred()) SWIG_fail;
28748 }
28749 Py_INCREF(Py_None); resultobj = Py_None;
28750 return resultobj;
28751 fail:
28752 return NULL;
28753 }
28754
28755
28756 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
28757 PyObject *resultobj;
28758 wxWindow *arg1 = (wxWindow *) 0 ;
28759 wxRect *arg2 = 0 ;
28760 bool arg3 = (bool) true ;
28761 wxRect temp2 ;
28762 PyObject * obj0 = 0 ;
28763 PyObject * obj1 = 0 ;
28764 PyObject * obj2 = 0 ;
28765 char *kwnames[] = {
28766 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
28767 };
28768
28769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
28770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28771 if (SWIG_arg_fail(1)) SWIG_fail;
28772 {
28773 arg2 = &temp2;
28774 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28775 }
28776 if (obj2) {
28777 {
28778 arg3 = (bool)(SWIG_As_bool(obj2));
28779 if (SWIG_arg_fail(3)) SWIG_fail;
28780 }
28781 }
28782 {
28783 PyThreadState* __tstate = wxPyBeginAllowThreads();
28784 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
28785
28786 wxPyEndAllowThreads(__tstate);
28787 if (PyErr_Occurred()) SWIG_fail;
28788 }
28789 Py_INCREF(Py_None); resultobj = Py_None;
28790 return resultobj;
28791 fail:
28792 return NULL;
28793 }
28794
28795
28796 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
28797 PyObject *resultobj;
28798 wxWindow *arg1 = (wxWindow *) 0 ;
28799 PyObject * obj0 = 0 ;
28800 char *kwnames[] = {
28801 (char *) "self", NULL
28802 };
28803
28804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
28805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28806 if (SWIG_arg_fail(1)) SWIG_fail;
28807 {
28808 PyThreadState* __tstate = wxPyBeginAllowThreads();
28809 (arg1)->Update();
28810
28811 wxPyEndAllowThreads(__tstate);
28812 if (PyErr_Occurred()) SWIG_fail;
28813 }
28814 Py_INCREF(Py_None); resultobj = Py_None;
28815 return resultobj;
28816 fail:
28817 return NULL;
28818 }
28819
28820
28821 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
28822 PyObject *resultobj;
28823 wxWindow *arg1 = (wxWindow *) 0 ;
28824 PyObject * obj0 = 0 ;
28825 char *kwnames[] = {
28826 (char *) "self", NULL
28827 };
28828
28829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
28830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28831 if (SWIG_arg_fail(1)) SWIG_fail;
28832 {
28833 PyThreadState* __tstate = wxPyBeginAllowThreads();
28834 (arg1)->ClearBackground();
28835
28836 wxPyEndAllowThreads(__tstate);
28837 if (PyErr_Occurred()) SWIG_fail;
28838 }
28839 Py_INCREF(Py_None); resultobj = Py_None;
28840 return resultobj;
28841 fail:
28842 return NULL;
28843 }
28844
28845
28846 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
28847 PyObject *resultobj;
28848 wxWindow *arg1 = (wxWindow *) 0 ;
28849 PyObject * obj0 = 0 ;
28850 char *kwnames[] = {
28851 (char *) "self", NULL
28852 };
28853
28854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
28855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28856 if (SWIG_arg_fail(1)) SWIG_fail;
28857 {
28858 PyThreadState* __tstate = wxPyBeginAllowThreads();
28859 (arg1)->Freeze();
28860
28861 wxPyEndAllowThreads(__tstate);
28862 if (PyErr_Occurred()) SWIG_fail;
28863 }
28864 Py_INCREF(Py_None); resultobj = Py_None;
28865 return resultobj;
28866 fail:
28867 return NULL;
28868 }
28869
28870
28871 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
28872 PyObject *resultobj;
28873 wxWindow *arg1 = (wxWindow *) 0 ;
28874 PyObject * obj0 = 0 ;
28875 char *kwnames[] = {
28876 (char *) "self", NULL
28877 };
28878
28879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
28880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28881 if (SWIG_arg_fail(1)) SWIG_fail;
28882 {
28883 PyThreadState* __tstate = wxPyBeginAllowThreads();
28884 (arg1)->Thaw();
28885
28886 wxPyEndAllowThreads(__tstate);
28887 if (PyErr_Occurred()) SWIG_fail;
28888 }
28889 Py_INCREF(Py_None); resultobj = Py_None;
28890 return resultobj;
28891 fail:
28892 return NULL;
28893 }
28894
28895
28896 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
28897 PyObject *resultobj;
28898 wxWindow *arg1 = (wxWindow *) 0 ;
28899 wxDC *arg2 = 0 ;
28900 PyObject * obj0 = 0 ;
28901 PyObject * obj1 = 0 ;
28902 char *kwnames[] = {
28903 (char *) "self",(char *) "dc", NULL
28904 };
28905
28906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
28907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28908 if (SWIG_arg_fail(1)) SWIG_fail;
28909 {
28910 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
28911 if (SWIG_arg_fail(2)) SWIG_fail;
28912 if (arg2 == NULL) {
28913 SWIG_null_ref("wxDC");
28914 }
28915 if (SWIG_arg_fail(2)) SWIG_fail;
28916 }
28917 {
28918 PyThreadState* __tstate = wxPyBeginAllowThreads();
28919 (arg1)->PrepareDC(*arg2);
28920
28921 wxPyEndAllowThreads(__tstate);
28922 if (PyErr_Occurred()) SWIG_fail;
28923 }
28924 Py_INCREF(Py_None); resultobj = Py_None;
28925 return resultobj;
28926 fail:
28927 return NULL;
28928 }
28929
28930
28931 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
28932 PyObject *resultobj;
28933 wxWindow *arg1 = (wxWindow *) 0 ;
28934 wxRegion *result;
28935 PyObject * obj0 = 0 ;
28936 char *kwnames[] = {
28937 (char *) "self", NULL
28938 };
28939
28940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
28941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28942 if (SWIG_arg_fail(1)) SWIG_fail;
28943 {
28944 PyThreadState* __tstate = wxPyBeginAllowThreads();
28945 {
28946 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
28947 result = (wxRegion *) &_result_ref;
28948 }
28949
28950 wxPyEndAllowThreads(__tstate);
28951 if (PyErr_Occurred()) SWIG_fail;
28952 }
28953 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
28954 return resultobj;
28955 fail:
28956 return NULL;
28957 }
28958
28959
28960 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
28961 PyObject *resultobj;
28962 wxWindow *arg1 = (wxWindow *) 0 ;
28963 wxRect result;
28964 PyObject * obj0 = 0 ;
28965 char *kwnames[] = {
28966 (char *) "self", NULL
28967 };
28968
28969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
28970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28971 if (SWIG_arg_fail(1)) SWIG_fail;
28972 {
28973 PyThreadState* __tstate = wxPyBeginAllowThreads();
28974 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
28975
28976 wxPyEndAllowThreads(__tstate);
28977 if (PyErr_Occurred()) SWIG_fail;
28978 }
28979 {
28980 wxRect * resultptr;
28981 resultptr = new wxRect((wxRect &)(result));
28982 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
28983 }
28984 return resultobj;
28985 fail:
28986 return NULL;
28987 }
28988
28989
28990 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
28991 PyObject *resultobj;
28992 wxWindow *arg1 = (wxWindow *) 0 ;
28993 int arg2 ;
28994 int arg3 ;
28995 int arg4 = (int) 1 ;
28996 int arg5 = (int) 1 ;
28997 bool result;
28998 PyObject * obj0 = 0 ;
28999 PyObject * obj1 = 0 ;
29000 PyObject * obj2 = 0 ;
29001 PyObject * obj3 = 0 ;
29002 PyObject * obj4 = 0 ;
29003 char *kwnames[] = {
29004 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29005 };
29006
29007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29009 if (SWIG_arg_fail(1)) SWIG_fail;
29010 {
29011 arg2 = (int)(SWIG_As_int(obj1));
29012 if (SWIG_arg_fail(2)) SWIG_fail;
29013 }
29014 {
29015 arg3 = (int)(SWIG_As_int(obj2));
29016 if (SWIG_arg_fail(3)) SWIG_fail;
29017 }
29018 if (obj3) {
29019 {
29020 arg4 = (int)(SWIG_As_int(obj3));
29021 if (SWIG_arg_fail(4)) SWIG_fail;
29022 }
29023 }
29024 if (obj4) {
29025 {
29026 arg5 = (int)(SWIG_As_int(obj4));
29027 if (SWIG_arg_fail(5)) SWIG_fail;
29028 }
29029 }
29030 {
29031 PyThreadState* __tstate = wxPyBeginAllowThreads();
29032 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29033
29034 wxPyEndAllowThreads(__tstate);
29035 if (PyErr_Occurred()) SWIG_fail;
29036 }
29037 {
29038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29039 }
29040 return resultobj;
29041 fail:
29042 return NULL;
29043 }
29044
29045
29046 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29047 PyObject *resultobj;
29048 wxWindow *arg1 = (wxWindow *) 0 ;
29049 wxPoint *arg2 = 0 ;
29050 bool result;
29051 wxPoint temp2 ;
29052 PyObject * obj0 = 0 ;
29053 PyObject * obj1 = 0 ;
29054 char *kwnames[] = {
29055 (char *) "self",(char *) "pt", NULL
29056 };
29057
29058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29060 if (SWIG_arg_fail(1)) SWIG_fail;
29061 {
29062 arg2 = &temp2;
29063 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29064 }
29065 {
29066 PyThreadState* __tstate = wxPyBeginAllowThreads();
29067 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29068
29069 wxPyEndAllowThreads(__tstate);
29070 if (PyErr_Occurred()) SWIG_fail;
29071 }
29072 {
29073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29074 }
29075 return resultobj;
29076 fail:
29077 return NULL;
29078 }
29079
29080
29081 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29082 PyObject *resultobj;
29083 wxWindow *arg1 = (wxWindow *) 0 ;
29084 wxRect *arg2 = 0 ;
29085 bool result;
29086 wxRect temp2 ;
29087 PyObject * obj0 = 0 ;
29088 PyObject * obj1 = 0 ;
29089 char *kwnames[] = {
29090 (char *) "self",(char *) "rect", NULL
29091 };
29092
29093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
29098 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29099 }
29100 {
29101 PyThreadState* __tstate = wxPyBeginAllowThreads();
29102 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29103
29104 wxPyEndAllowThreads(__tstate);
29105 if (PyErr_Occurred()) SWIG_fail;
29106 }
29107 {
29108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29109 }
29110 return resultobj;
29111 fail:
29112 return NULL;
29113 }
29114
29115
29116 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29117 PyObject *resultobj;
29118 wxWindow *arg1 = (wxWindow *) 0 ;
29119 wxVisualAttributes result;
29120 PyObject * obj0 = 0 ;
29121 char *kwnames[] = {
29122 (char *) "self", NULL
29123 };
29124
29125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29127 if (SWIG_arg_fail(1)) SWIG_fail;
29128 {
29129 PyThreadState* __tstate = wxPyBeginAllowThreads();
29130 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29131
29132 wxPyEndAllowThreads(__tstate);
29133 if (PyErr_Occurred()) SWIG_fail;
29134 }
29135 {
29136 wxVisualAttributes * resultptr;
29137 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29138 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29139 }
29140 return resultobj;
29141 fail:
29142 return NULL;
29143 }
29144
29145
29146 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29147 PyObject *resultobj;
29148 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29149 wxVisualAttributes result;
29150 PyObject * obj0 = 0 ;
29151 char *kwnames[] = {
29152 (char *) "variant", NULL
29153 };
29154
29155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29156 if (obj0) {
29157 {
29158 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29159 if (SWIG_arg_fail(1)) SWIG_fail;
29160 }
29161 }
29162 {
29163 if (!wxPyCheckForApp()) SWIG_fail;
29164 PyThreadState* __tstate = wxPyBeginAllowThreads();
29165 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29166
29167 wxPyEndAllowThreads(__tstate);
29168 if (PyErr_Occurred()) SWIG_fail;
29169 }
29170 {
29171 wxVisualAttributes * resultptr;
29172 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29173 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29174 }
29175 return resultobj;
29176 fail:
29177 return NULL;
29178 }
29179
29180
29181 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29182 PyObject *resultobj;
29183 wxWindow *arg1 = (wxWindow *) 0 ;
29184 wxColour *arg2 = 0 ;
29185 bool result;
29186 wxColour temp2 ;
29187 PyObject * obj0 = 0 ;
29188 PyObject * obj1 = 0 ;
29189 char *kwnames[] = {
29190 (char *) "self",(char *) "colour", NULL
29191 };
29192
29193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29195 if (SWIG_arg_fail(1)) SWIG_fail;
29196 {
29197 arg2 = &temp2;
29198 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29199 }
29200 {
29201 PyThreadState* __tstate = wxPyBeginAllowThreads();
29202 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29203
29204 wxPyEndAllowThreads(__tstate);
29205 if (PyErr_Occurred()) SWIG_fail;
29206 }
29207 {
29208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29209 }
29210 return resultobj;
29211 fail:
29212 return NULL;
29213 }
29214
29215
29216 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29217 PyObject *resultobj;
29218 wxWindow *arg1 = (wxWindow *) 0 ;
29219 wxColour *arg2 = 0 ;
29220 wxColour temp2 ;
29221 PyObject * obj0 = 0 ;
29222 PyObject * obj1 = 0 ;
29223 char *kwnames[] = {
29224 (char *) "self",(char *) "colour", NULL
29225 };
29226
29227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29229 if (SWIG_arg_fail(1)) SWIG_fail;
29230 {
29231 arg2 = &temp2;
29232 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29233 }
29234 {
29235 PyThreadState* __tstate = wxPyBeginAllowThreads();
29236 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29237
29238 wxPyEndAllowThreads(__tstate);
29239 if (PyErr_Occurred()) SWIG_fail;
29240 }
29241 Py_INCREF(Py_None); resultobj = Py_None;
29242 return resultobj;
29243 fail:
29244 return NULL;
29245 }
29246
29247
29248 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29249 PyObject *resultobj;
29250 wxWindow *arg1 = (wxWindow *) 0 ;
29251 wxColour *arg2 = 0 ;
29252 bool result;
29253 wxColour temp2 ;
29254 PyObject * obj0 = 0 ;
29255 PyObject * obj1 = 0 ;
29256 char *kwnames[] = {
29257 (char *) "self",(char *) "colour", NULL
29258 };
29259
29260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29262 if (SWIG_arg_fail(1)) SWIG_fail;
29263 {
29264 arg2 = &temp2;
29265 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29266 }
29267 {
29268 PyThreadState* __tstate = wxPyBeginAllowThreads();
29269 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29270
29271 wxPyEndAllowThreads(__tstate);
29272 if (PyErr_Occurred()) SWIG_fail;
29273 }
29274 {
29275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29276 }
29277 return resultobj;
29278 fail:
29279 return NULL;
29280 }
29281
29282
29283 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29284 PyObject *resultobj;
29285 wxWindow *arg1 = (wxWindow *) 0 ;
29286 wxColour *arg2 = 0 ;
29287 wxColour temp2 ;
29288 PyObject * obj0 = 0 ;
29289 PyObject * obj1 = 0 ;
29290 char *kwnames[] = {
29291 (char *) "self",(char *) "colour", NULL
29292 };
29293
29294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29296 if (SWIG_arg_fail(1)) SWIG_fail;
29297 {
29298 arg2 = &temp2;
29299 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29300 }
29301 {
29302 PyThreadState* __tstate = wxPyBeginAllowThreads();
29303 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29304
29305 wxPyEndAllowThreads(__tstate);
29306 if (PyErr_Occurred()) SWIG_fail;
29307 }
29308 Py_INCREF(Py_None); resultobj = Py_None;
29309 return resultobj;
29310 fail:
29311 return NULL;
29312 }
29313
29314
29315 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29316 PyObject *resultobj;
29317 wxWindow *arg1 = (wxWindow *) 0 ;
29318 wxColour result;
29319 PyObject * obj0 = 0 ;
29320 char *kwnames[] = {
29321 (char *) "self", NULL
29322 };
29323
29324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29326 if (SWIG_arg_fail(1)) SWIG_fail;
29327 {
29328 PyThreadState* __tstate = wxPyBeginAllowThreads();
29329 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29330
29331 wxPyEndAllowThreads(__tstate);
29332 if (PyErr_Occurred()) SWIG_fail;
29333 }
29334 {
29335 wxColour * resultptr;
29336 resultptr = new wxColour((wxColour &)(result));
29337 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29338 }
29339 return resultobj;
29340 fail:
29341 return NULL;
29342 }
29343
29344
29345 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29346 PyObject *resultobj;
29347 wxWindow *arg1 = (wxWindow *) 0 ;
29348 wxColour result;
29349 PyObject * obj0 = 0 ;
29350 char *kwnames[] = {
29351 (char *) "self", NULL
29352 };
29353
29354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29356 if (SWIG_arg_fail(1)) SWIG_fail;
29357 {
29358 PyThreadState* __tstate = wxPyBeginAllowThreads();
29359 result = ((wxWindow const *)arg1)->GetForegroundColour();
29360
29361 wxPyEndAllowThreads(__tstate);
29362 if (PyErr_Occurred()) SWIG_fail;
29363 }
29364 {
29365 wxColour * resultptr;
29366 resultptr = new wxColour((wxColour &)(result));
29367 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29368 }
29369 return resultobj;
29370 fail:
29371 return NULL;
29372 }
29373
29374
29375 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29376 PyObject *resultobj;
29377 wxWindow *arg1 = (wxWindow *) 0 ;
29378 wxBackgroundStyle arg2 ;
29379 bool result;
29380 PyObject * obj0 = 0 ;
29381 PyObject * obj1 = 0 ;
29382 char *kwnames[] = {
29383 (char *) "self",(char *) "style", NULL
29384 };
29385
29386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29388 if (SWIG_arg_fail(1)) SWIG_fail;
29389 {
29390 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29391 if (SWIG_arg_fail(2)) SWIG_fail;
29392 }
29393 {
29394 PyThreadState* __tstate = wxPyBeginAllowThreads();
29395 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29396
29397 wxPyEndAllowThreads(__tstate);
29398 if (PyErr_Occurred()) SWIG_fail;
29399 }
29400 {
29401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29402 }
29403 return resultobj;
29404 fail:
29405 return NULL;
29406 }
29407
29408
29409 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29410 PyObject *resultobj;
29411 wxWindow *arg1 = (wxWindow *) 0 ;
29412 wxBackgroundStyle result;
29413 PyObject * obj0 = 0 ;
29414 char *kwnames[] = {
29415 (char *) "self", NULL
29416 };
29417
29418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29420 if (SWIG_arg_fail(1)) SWIG_fail;
29421 {
29422 PyThreadState* __tstate = wxPyBeginAllowThreads();
29423 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29424
29425 wxPyEndAllowThreads(__tstate);
29426 if (PyErr_Occurred()) SWIG_fail;
29427 }
29428 resultobj = SWIG_From_int((result));
29429 return resultobj;
29430 fail:
29431 return NULL;
29432 }
29433
29434
29435 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29436 PyObject *resultobj;
29437 wxWindow *arg1 = (wxWindow *) 0 ;
29438 bool result;
29439 PyObject * obj0 = 0 ;
29440 char *kwnames[] = {
29441 (char *) "self", NULL
29442 };
29443
29444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29446 if (SWIG_arg_fail(1)) SWIG_fail;
29447 {
29448 PyThreadState* __tstate = wxPyBeginAllowThreads();
29449 result = (bool)(arg1)->HasTransparentBackground();
29450
29451 wxPyEndAllowThreads(__tstate);
29452 if (PyErr_Occurred()) SWIG_fail;
29453 }
29454 {
29455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29456 }
29457 return resultobj;
29458 fail:
29459 return NULL;
29460 }
29461
29462
29463 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29464 PyObject *resultobj;
29465 wxWindow *arg1 = (wxWindow *) 0 ;
29466 wxCursor *arg2 = 0 ;
29467 bool result;
29468 PyObject * obj0 = 0 ;
29469 PyObject * obj1 = 0 ;
29470 char *kwnames[] = {
29471 (char *) "self",(char *) "cursor", NULL
29472 };
29473
29474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29476 if (SWIG_arg_fail(1)) SWIG_fail;
29477 {
29478 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29479 if (SWIG_arg_fail(2)) SWIG_fail;
29480 if (arg2 == NULL) {
29481 SWIG_null_ref("wxCursor");
29482 }
29483 if (SWIG_arg_fail(2)) SWIG_fail;
29484 }
29485 {
29486 PyThreadState* __tstate = wxPyBeginAllowThreads();
29487 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29488
29489 wxPyEndAllowThreads(__tstate);
29490 if (PyErr_Occurred()) SWIG_fail;
29491 }
29492 {
29493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29494 }
29495 return resultobj;
29496 fail:
29497 return NULL;
29498 }
29499
29500
29501 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29502 PyObject *resultobj;
29503 wxWindow *arg1 = (wxWindow *) 0 ;
29504 wxCursor result;
29505 PyObject * obj0 = 0 ;
29506 char *kwnames[] = {
29507 (char *) "self", NULL
29508 };
29509
29510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29512 if (SWIG_arg_fail(1)) SWIG_fail;
29513 {
29514 PyThreadState* __tstate = wxPyBeginAllowThreads();
29515 result = (arg1)->GetCursor();
29516
29517 wxPyEndAllowThreads(__tstate);
29518 if (PyErr_Occurred()) SWIG_fail;
29519 }
29520 {
29521 wxCursor * resultptr;
29522 resultptr = new wxCursor((wxCursor &)(result));
29523 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29524 }
29525 return resultobj;
29526 fail:
29527 return NULL;
29528 }
29529
29530
29531 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29532 PyObject *resultobj;
29533 wxWindow *arg1 = (wxWindow *) 0 ;
29534 wxFont *arg2 = 0 ;
29535 bool result;
29536 PyObject * obj0 = 0 ;
29537 PyObject * obj1 = 0 ;
29538 char *kwnames[] = {
29539 (char *) "self",(char *) "font", NULL
29540 };
29541
29542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29544 if (SWIG_arg_fail(1)) SWIG_fail;
29545 {
29546 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29547 if (SWIG_arg_fail(2)) SWIG_fail;
29548 if (arg2 == NULL) {
29549 SWIG_null_ref("wxFont");
29550 }
29551 if (SWIG_arg_fail(2)) SWIG_fail;
29552 }
29553 {
29554 PyThreadState* __tstate = wxPyBeginAllowThreads();
29555 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29556
29557 wxPyEndAllowThreads(__tstate);
29558 if (PyErr_Occurred()) SWIG_fail;
29559 }
29560 {
29561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29562 }
29563 return resultobj;
29564 fail:
29565 return NULL;
29566 }
29567
29568
29569 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29570 PyObject *resultobj;
29571 wxWindow *arg1 = (wxWindow *) 0 ;
29572 wxFont *arg2 = 0 ;
29573 PyObject * obj0 = 0 ;
29574 PyObject * obj1 = 0 ;
29575 char *kwnames[] = {
29576 (char *) "self",(char *) "font", NULL
29577 };
29578
29579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29581 if (SWIG_arg_fail(1)) SWIG_fail;
29582 {
29583 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29584 if (SWIG_arg_fail(2)) SWIG_fail;
29585 if (arg2 == NULL) {
29586 SWIG_null_ref("wxFont");
29587 }
29588 if (SWIG_arg_fail(2)) SWIG_fail;
29589 }
29590 {
29591 PyThreadState* __tstate = wxPyBeginAllowThreads();
29592 (arg1)->SetOwnFont((wxFont const &)*arg2);
29593
29594 wxPyEndAllowThreads(__tstate);
29595 if (PyErr_Occurred()) SWIG_fail;
29596 }
29597 Py_INCREF(Py_None); resultobj = Py_None;
29598 return resultobj;
29599 fail:
29600 return NULL;
29601 }
29602
29603
29604 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29605 PyObject *resultobj;
29606 wxWindow *arg1 = (wxWindow *) 0 ;
29607 wxFont result;
29608 PyObject * obj0 = 0 ;
29609 char *kwnames[] = {
29610 (char *) "self", NULL
29611 };
29612
29613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29615 if (SWIG_arg_fail(1)) SWIG_fail;
29616 {
29617 PyThreadState* __tstate = wxPyBeginAllowThreads();
29618 result = (arg1)->GetFont();
29619
29620 wxPyEndAllowThreads(__tstate);
29621 if (PyErr_Occurred()) SWIG_fail;
29622 }
29623 {
29624 wxFont * resultptr;
29625 resultptr = new wxFont((wxFont &)(result));
29626 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29627 }
29628 return resultobj;
29629 fail:
29630 return NULL;
29631 }
29632
29633
29634 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29635 PyObject *resultobj;
29636 wxWindow *arg1 = (wxWindow *) 0 ;
29637 wxCaret *arg2 = (wxCaret *) 0 ;
29638 PyObject * obj0 = 0 ;
29639 PyObject * obj1 = 0 ;
29640 char *kwnames[] = {
29641 (char *) "self",(char *) "caret", NULL
29642 };
29643
29644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
29645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29646 if (SWIG_arg_fail(1)) SWIG_fail;
29647 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
29648 if (SWIG_arg_fail(2)) SWIG_fail;
29649 {
29650 PyThreadState* __tstate = wxPyBeginAllowThreads();
29651 (arg1)->SetCaret(arg2);
29652
29653 wxPyEndAllowThreads(__tstate);
29654 if (PyErr_Occurred()) SWIG_fail;
29655 }
29656 Py_INCREF(Py_None); resultobj = Py_None;
29657 return resultobj;
29658 fail:
29659 return NULL;
29660 }
29661
29662
29663 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29664 PyObject *resultobj;
29665 wxWindow *arg1 = (wxWindow *) 0 ;
29666 wxCaret *result;
29667 PyObject * obj0 = 0 ;
29668 char *kwnames[] = {
29669 (char *) "self", NULL
29670 };
29671
29672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
29673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29674 if (SWIG_arg_fail(1)) SWIG_fail;
29675 {
29676 PyThreadState* __tstate = wxPyBeginAllowThreads();
29677 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
29678
29679 wxPyEndAllowThreads(__tstate);
29680 if (PyErr_Occurred()) SWIG_fail;
29681 }
29682 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
29683 return resultobj;
29684 fail:
29685 return NULL;
29686 }
29687
29688
29689 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29690 PyObject *resultobj;
29691 wxWindow *arg1 = (wxWindow *) 0 ;
29692 int result;
29693 PyObject * obj0 = 0 ;
29694 char *kwnames[] = {
29695 (char *) "self", NULL
29696 };
29697
29698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
29699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29700 if (SWIG_arg_fail(1)) SWIG_fail;
29701 {
29702 PyThreadState* __tstate = wxPyBeginAllowThreads();
29703 result = (int)((wxWindow const *)arg1)->GetCharHeight();
29704
29705 wxPyEndAllowThreads(__tstate);
29706 if (PyErr_Occurred()) SWIG_fail;
29707 }
29708 {
29709 resultobj = SWIG_From_int((int)(result));
29710 }
29711 return resultobj;
29712 fail:
29713 return NULL;
29714 }
29715
29716
29717 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29718 PyObject *resultobj;
29719 wxWindow *arg1 = (wxWindow *) 0 ;
29720 int result;
29721 PyObject * obj0 = 0 ;
29722 char *kwnames[] = {
29723 (char *) "self", NULL
29724 };
29725
29726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
29727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29728 if (SWIG_arg_fail(1)) SWIG_fail;
29729 {
29730 PyThreadState* __tstate = wxPyBeginAllowThreads();
29731 result = (int)((wxWindow const *)arg1)->GetCharWidth();
29732
29733 wxPyEndAllowThreads(__tstate);
29734 if (PyErr_Occurred()) SWIG_fail;
29735 }
29736 {
29737 resultobj = SWIG_From_int((int)(result));
29738 }
29739 return resultobj;
29740 fail:
29741 return NULL;
29742 }
29743
29744
29745 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29746 PyObject *resultobj;
29747 wxWindow *arg1 = (wxWindow *) 0 ;
29748 wxString *arg2 = 0 ;
29749 int *arg3 = (int *) 0 ;
29750 int *arg4 = (int *) 0 ;
29751 bool temp2 = false ;
29752 int temp3 ;
29753 int res3 = 0 ;
29754 int temp4 ;
29755 int res4 = 0 ;
29756 PyObject * obj0 = 0 ;
29757 PyObject * obj1 = 0 ;
29758 char *kwnames[] = {
29759 (char *) "self",(char *) "string", NULL
29760 };
29761
29762 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29763 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
29765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29766 if (SWIG_arg_fail(1)) SWIG_fail;
29767 {
29768 arg2 = wxString_in_helper(obj1);
29769 if (arg2 == NULL) SWIG_fail;
29770 temp2 = true;
29771 }
29772 {
29773 PyThreadState* __tstate = wxPyBeginAllowThreads();
29774 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
29775
29776 wxPyEndAllowThreads(__tstate);
29777 if (PyErr_Occurred()) SWIG_fail;
29778 }
29779 Py_INCREF(Py_None); resultobj = Py_None;
29780 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29781 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29782 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29783 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29784 {
29785 if (temp2)
29786 delete arg2;
29787 }
29788 return resultobj;
29789 fail:
29790 {
29791 if (temp2)
29792 delete arg2;
29793 }
29794 return NULL;
29795 }
29796
29797
29798 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29799 PyObject *resultobj;
29800 wxWindow *arg1 = (wxWindow *) 0 ;
29801 wxString *arg2 = 0 ;
29802 int *arg3 = (int *) 0 ;
29803 int *arg4 = (int *) 0 ;
29804 int *arg5 = (int *) 0 ;
29805 int *arg6 = (int *) 0 ;
29806 wxFont *arg7 = (wxFont *) NULL ;
29807 bool temp2 = false ;
29808 int temp3 ;
29809 int res3 = 0 ;
29810 int temp4 ;
29811 int res4 = 0 ;
29812 int temp5 ;
29813 int res5 = 0 ;
29814 int temp6 ;
29815 int res6 = 0 ;
29816 PyObject * obj0 = 0 ;
29817 PyObject * obj1 = 0 ;
29818 PyObject * obj2 = 0 ;
29819 char *kwnames[] = {
29820 (char *) "self",(char *) "string",(char *) "font", NULL
29821 };
29822
29823 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29824 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29825 arg5 = &temp5; res5 = SWIG_NEWOBJ;
29826 arg6 = &temp6; res6 = SWIG_NEWOBJ;
29827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
29828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29829 if (SWIG_arg_fail(1)) SWIG_fail;
29830 {
29831 arg2 = wxString_in_helper(obj1);
29832 if (arg2 == NULL) SWIG_fail;
29833 temp2 = true;
29834 }
29835 if (obj2) {
29836 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29837 if (SWIG_arg_fail(7)) SWIG_fail;
29838 }
29839 {
29840 PyThreadState* __tstate = wxPyBeginAllowThreads();
29841 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
29842
29843 wxPyEndAllowThreads(__tstate);
29844 if (PyErr_Occurred()) SWIG_fail;
29845 }
29846 Py_INCREF(Py_None); resultobj = Py_None;
29847 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29848 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29849 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29850 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29851 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
29852 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
29853 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
29854 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
29855 {
29856 if (temp2)
29857 delete arg2;
29858 }
29859 return resultobj;
29860 fail:
29861 {
29862 if (temp2)
29863 delete arg2;
29864 }
29865 return NULL;
29866 }
29867
29868
29869 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
29870 PyObject *resultobj;
29871 wxWindow *arg1 = (wxWindow *) 0 ;
29872 int *arg2 = (int *) 0 ;
29873 int *arg3 = (int *) 0 ;
29874 int temp2 ;
29875 int res2 = 0 ;
29876 int temp3 ;
29877 int res3 = 0 ;
29878 PyObject * obj0 = 0 ;
29879 PyObject * obj1 = 0 ;
29880 PyObject * obj2 = 0 ;
29881 char *kwnames[] = {
29882 (char *) "self",(char *) "x",(char *) "y", NULL
29883 };
29884
29885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29887 if (SWIG_arg_fail(1)) SWIG_fail;
29888 {
29889 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29890 temp2 = SWIG_As_int(obj1);
29891 if (SWIG_arg_fail(2)) SWIG_fail;
29892 arg2 = &temp2;
29893 res2 = SWIG_NEWOBJ;
29894 }
29895 }
29896 {
29897 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29898 temp3 = SWIG_As_int(obj2);
29899 if (SWIG_arg_fail(3)) SWIG_fail;
29900 arg3 = &temp3;
29901 res3 = SWIG_NEWOBJ;
29902 }
29903 }
29904 {
29905 PyThreadState* __tstate = wxPyBeginAllowThreads();
29906 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
29907
29908 wxPyEndAllowThreads(__tstate);
29909 if (PyErr_Occurred()) SWIG_fail;
29910 }
29911 Py_INCREF(Py_None); resultobj = Py_None;
29912 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29913 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29914 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29915 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29916 return resultobj;
29917 fail:
29918 return NULL;
29919 }
29920
29921
29922 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
29923 PyObject *resultobj;
29924 wxWindow *arg1 = (wxWindow *) 0 ;
29925 int *arg2 = (int *) 0 ;
29926 int *arg3 = (int *) 0 ;
29927 int temp2 ;
29928 int res2 = 0 ;
29929 int temp3 ;
29930 int res3 = 0 ;
29931 PyObject * obj0 = 0 ;
29932 PyObject * obj1 = 0 ;
29933 PyObject * obj2 = 0 ;
29934 char *kwnames[] = {
29935 (char *) "self",(char *) "x",(char *) "y", NULL
29936 };
29937
29938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29940 if (SWIG_arg_fail(1)) SWIG_fail;
29941 {
29942 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29943 temp2 = SWIG_As_int(obj1);
29944 if (SWIG_arg_fail(2)) SWIG_fail;
29945 arg2 = &temp2;
29946 res2 = SWIG_NEWOBJ;
29947 }
29948 }
29949 {
29950 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29951 temp3 = SWIG_As_int(obj2);
29952 if (SWIG_arg_fail(3)) SWIG_fail;
29953 arg3 = &temp3;
29954 res3 = SWIG_NEWOBJ;
29955 }
29956 }
29957 {
29958 PyThreadState* __tstate = wxPyBeginAllowThreads();
29959 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
29960
29961 wxPyEndAllowThreads(__tstate);
29962 if (PyErr_Occurred()) SWIG_fail;
29963 }
29964 Py_INCREF(Py_None); resultobj = Py_None;
29965 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29966 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29967 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29968 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29969 return resultobj;
29970 fail:
29971 return NULL;
29972 }
29973
29974
29975 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
29976 PyObject *resultobj;
29977 wxWindow *arg1 = (wxWindow *) 0 ;
29978 wxPoint *arg2 = 0 ;
29979 wxPoint result;
29980 wxPoint temp2 ;
29981 PyObject * obj0 = 0 ;
29982 PyObject * obj1 = 0 ;
29983 char *kwnames[] = {
29984 (char *) "self",(char *) "pt", NULL
29985 };
29986
29987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
29988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29989 if (SWIG_arg_fail(1)) SWIG_fail;
29990 {
29991 arg2 = &temp2;
29992 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29993 }
29994 {
29995 PyThreadState* __tstate = wxPyBeginAllowThreads();
29996 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
29997
29998 wxPyEndAllowThreads(__tstate);
29999 if (PyErr_Occurred()) SWIG_fail;
30000 }
30001 {
30002 wxPoint * resultptr;
30003 resultptr = new wxPoint((wxPoint &)(result));
30004 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30005 }
30006 return resultobj;
30007 fail:
30008 return NULL;
30009 }
30010
30011
30012 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30013 PyObject *resultobj;
30014 wxWindow *arg1 = (wxWindow *) 0 ;
30015 wxPoint *arg2 = 0 ;
30016 wxPoint result;
30017 wxPoint temp2 ;
30018 PyObject * obj0 = 0 ;
30019 PyObject * obj1 = 0 ;
30020 char *kwnames[] = {
30021 (char *) "self",(char *) "pt", NULL
30022 };
30023
30024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30026 if (SWIG_arg_fail(1)) SWIG_fail;
30027 {
30028 arg2 = &temp2;
30029 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30030 }
30031 {
30032 PyThreadState* __tstate = wxPyBeginAllowThreads();
30033 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30034
30035 wxPyEndAllowThreads(__tstate);
30036 if (PyErr_Occurred()) SWIG_fail;
30037 }
30038 {
30039 wxPoint * resultptr;
30040 resultptr = new wxPoint((wxPoint &)(result));
30041 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30042 }
30043 return resultobj;
30044 fail:
30045 return NULL;
30046 }
30047
30048
30049 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30050 PyObject *resultobj;
30051 wxWindow *arg1 = (wxWindow *) 0 ;
30052 int arg2 ;
30053 int arg3 ;
30054 wxHitTest result;
30055 PyObject * obj0 = 0 ;
30056 PyObject * obj1 = 0 ;
30057 PyObject * obj2 = 0 ;
30058 char *kwnames[] = {
30059 (char *) "self",(char *) "x",(char *) "y", NULL
30060 };
30061
30062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30064 if (SWIG_arg_fail(1)) SWIG_fail;
30065 {
30066 arg2 = (int)(SWIG_As_int(obj1));
30067 if (SWIG_arg_fail(2)) SWIG_fail;
30068 }
30069 {
30070 arg3 = (int)(SWIG_As_int(obj2));
30071 if (SWIG_arg_fail(3)) SWIG_fail;
30072 }
30073 {
30074 PyThreadState* __tstate = wxPyBeginAllowThreads();
30075 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30076
30077 wxPyEndAllowThreads(__tstate);
30078 if (PyErr_Occurred()) SWIG_fail;
30079 }
30080 resultobj = SWIG_From_int((result));
30081 return resultobj;
30082 fail:
30083 return NULL;
30084 }
30085
30086
30087 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30088 PyObject *resultobj;
30089 wxWindow *arg1 = (wxWindow *) 0 ;
30090 wxPoint *arg2 = 0 ;
30091 wxHitTest result;
30092 wxPoint temp2 ;
30093 PyObject * obj0 = 0 ;
30094 PyObject * obj1 = 0 ;
30095 char *kwnames[] = {
30096 (char *) "self",(char *) "pt", NULL
30097 };
30098
30099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30101 if (SWIG_arg_fail(1)) SWIG_fail;
30102 {
30103 arg2 = &temp2;
30104 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30105 }
30106 {
30107 PyThreadState* __tstate = wxPyBeginAllowThreads();
30108 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30109
30110 wxPyEndAllowThreads(__tstate);
30111 if (PyErr_Occurred()) SWIG_fail;
30112 }
30113 resultobj = SWIG_From_int((result));
30114 return resultobj;
30115 fail:
30116 return NULL;
30117 }
30118
30119
30120 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30121 PyObject *resultobj;
30122 wxWindow *arg1 = (wxWindow *) 0 ;
30123 long arg2 ;
30124 wxBorder result;
30125 PyObject * obj0 = 0 ;
30126 PyObject * obj1 = 0 ;
30127
30128 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30130 if (SWIG_arg_fail(1)) SWIG_fail;
30131 {
30132 arg2 = (long)(SWIG_As_long(obj1));
30133 if (SWIG_arg_fail(2)) SWIG_fail;
30134 }
30135 {
30136 PyThreadState* __tstate = wxPyBeginAllowThreads();
30137 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30138
30139 wxPyEndAllowThreads(__tstate);
30140 if (PyErr_Occurred()) SWIG_fail;
30141 }
30142 resultobj = SWIG_From_int((result));
30143 return resultobj;
30144 fail:
30145 return NULL;
30146 }
30147
30148
30149 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30150 PyObject *resultobj;
30151 wxWindow *arg1 = (wxWindow *) 0 ;
30152 wxBorder result;
30153 PyObject * obj0 = 0 ;
30154
30155 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30157 if (SWIG_arg_fail(1)) SWIG_fail;
30158 {
30159 PyThreadState* __tstate = wxPyBeginAllowThreads();
30160 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30161
30162 wxPyEndAllowThreads(__tstate);
30163 if (PyErr_Occurred()) SWIG_fail;
30164 }
30165 resultobj = SWIG_From_int((result));
30166 return resultobj;
30167 fail:
30168 return NULL;
30169 }
30170
30171
30172 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30173 int argc;
30174 PyObject *argv[3];
30175 int ii;
30176
30177 argc = PyObject_Length(args);
30178 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30179 argv[ii] = PyTuple_GetItem(args,ii);
30180 }
30181 if (argc == 1) {
30182 int _v;
30183 {
30184 void *ptr;
30185 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30186 _v = 0;
30187 PyErr_Clear();
30188 } else {
30189 _v = 1;
30190 }
30191 }
30192 if (_v) {
30193 return _wrap_Window_GetBorder__SWIG_1(self,args);
30194 }
30195 }
30196 if (argc == 2) {
30197 int _v;
30198 {
30199 void *ptr;
30200 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30201 _v = 0;
30202 PyErr_Clear();
30203 } else {
30204 _v = 1;
30205 }
30206 }
30207 if (_v) {
30208 _v = SWIG_Check_long(argv[1]);
30209 if (_v) {
30210 return _wrap_Window_GetBorder__SWIG_0(self,args);
30211 }
30212 }
30213 }
30214
30215 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30216 return NULL;
30217 }
30218
30219
30220 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30221 PyObject *resultobj;
30222 wxWindow *arg1 = (wxWindow *) 0 ;
30223 long arg2 = (long) wxUPDATE_UI_NONE ;
30224 PyObject * obj0 = 0 ;
30225 PyObject * obj1 = 0 ;
30226 char *kwnames[] = {
30227 (char *) "self",(char *) "flags", NULL
30228 };
30229
30230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30232 if (SWIG_arg_fail(1)) SWIG_fail;
30233 if (obj1) {
30234 {
30235 arg2 = (long)(SWIG_As_long(obj1));
30236 if (SWIG_arg_fail(2)) SWIG_fail;
30237 }
30238 }
30239 {
30240 PyThreadState* __tstate = wxPyBeginAllowThreads();
30241 (arg1)->UpdateWindowUI(arg2);
30242
30243 wxPyEndAllowThreads(__tstate);
30244 if (PyErr_Occurred()) SWIG_fail;
30245 }
30246 Py_INCREF(Py_None); resultobj = Py_None;
30247 return resultobj;
30248 fail:
30249 return NULL;
30250 }
30251
30252
30253 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30254 PyObject *resultobj;
30255 wxWindow *arg1 = (wxWindow *) 0 ;
30256 wxMenu *arg2 = (wxMenu *) 0 ;
30257 int arg3 = (int) -1 ;
30258 int arg4 = (int) -1 ;
30259 bool result;
30260 PyObject * obj0 = 0 ;
30261 PyObject * obj1 = 0 ;
30262 PyObject * obj2 = 0 ;
30263 PyObject * obj3 = 0 ;
30264 char *kwnames[] = {
30265 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30266 };
30267
30268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30270 if (SWIG_arg_fail(1)) SWIG_fail;
30271 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30272 if (SWIG_arg_fail(2)) SWIG_fail;
30273 if (obj2) {
30274 {
30275 arg3 = (int)(SWIG_As_int(obj2));
30276 if (SWIG_arg_fail(3)) SWIG_fail;
30277 }
30278 }
30279 if (obj3) {
30280 {
30281 arg4 = (int)(SWIG_As_int(obj3));
30282 if (SWIG_arg_fail(4)) SWIG_fail;
30283 }
30284 }
30285 {
30286 PyThreadState* __tstate = wxPyBeginAllowThreads();
30287 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30288
30289 wxPyEndAllowThreads(__tstate);
30290 if (PyErr_Occurred()) SWIG_fail;
30291 }
30292 {
30293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30294 }
30295 return resultobj;
30296 fail:
30297 return NULL;
30298 }
30299
30300
30301 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30302 PyObject *resultobj;
30303 wxWindow *arg1 = (wxWindow *) 0 ;
30304 wxMenu *arg2 = (wxMenu *) 0 ;
30305 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30306 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30307 bool result;
30308 wxPoint temp3 ;
30309 PyObject * obj0 = 0 ;
30310 PyObject * obj1 = 0 ;
30311 PyObject * obj2 = 0 ;
30312 char *kwnames[] = {
30313 (char *) "self",(char *) "menu",(char *) "pos", NULL
30314 };
30315
30316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30318 if (SWIG_arg_fail(1)) SWIG_fail;
30319 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30320 if (SWIG_arg_fail(2)) SWIG_fail;
30321 if (obj2) {
30322 {
30323 arg3 = &temp3;
30324 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30325 }
30326 }
30327 {
30328 PyThreadState* __tstate = wxPyBeginAllowThreads();
30329 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30330
30331 wxPyEndAllowThreads(__tstate);
30332 if (PyErr_Occurred()) SWIG_fail;
30333 }
30334 {
30335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30336 }
30337 return resultobj;
30338 fail:
30339 return NULL;
30340 }
30341
30342
30343 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30344 PyObject *resultobj;
30345 wxWindow *arg1 = (wxWindow *) 0 ;
30346 long result;
30347 PyObject * obj0 = 0 ;
30348 char *kwnames[] = {
30349 (char *) "self", NULL
30350 };
30351
30352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30354 if (SWIG_arg_fail(1)) SWIG_fail;
30355 {
30356 PyThreadState* __tstate = wxPyBeginAllowThreads();
30357 result = (long)wxWindow_GetHandle(arg1);
30358
30359 wxPyEndAllowThreads(__tstate);
30360 if (PyErr_Occurred()) SWIG_fail;
30361 }
30362 {
30363 resultobj = SWIG_From_long((long)(result));
30364 }
30365 return resultobj;
30366 fail:
30367 return NULL;
30368 }
30369
30370
30371 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30372 PyObject *resultobj;
30373 wxWindow *arg1 = (wxWindow *) 0 ;
30374 long arg2 ;
30375 PyObject * obj0 = 0 ;
30376 PyObject * obj1 = 0 ;
30377 char *kwnames[] = {
30378 (char *) "self",(char *) "handle", NULL
30379 };
30380
30381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30383 if (SWIG_arg_fail(1)) SWIG_fail;
30384 {
30385 arg2 = (long)(SWIG_As_long(obj1));
30386 if (SWIG_arg_fail(2)) SWIG_fail;
30387 }
30388 {
30389 PyThreadState* __tstate = wxPyBeginAllowThreads();
30390 wxWindow_AssociateHandle(arg1,arg2);
30391
30392 wxPyEndAllowThreads(__tstate);
30393 if (PyErr_Occurred()) SWIG_fail;
30394 }
30395 Py_INCREF(Py_None); resultobj = Py_None;
30396 return resultobj;
30397 fail:
30398 return NULL;
30399 }
30400
30401
30402 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30403 PyObject *resultobj;
30404 wxWindow *arg1 = (wxWindow *) 0 ;
30405 PyObject * obj0 = 0 ;
30406 char *kwnames[] = {
30407 (char *) "self", NULL
30408 };
30409
30410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30412 if (SWIG_arg_fail(1)) SWIG_fail;
30413 {
30414 PyThreadState* __tstate = wxPyBeginAllowThreads();
30415 (arg1)->DissociateHandle();
30416
30417 wxPyEndAllowThreads(__tstate);
30418 if (PyErr_Occurred()) SWIG_fail;
30419 }
30420 Py_INCREF(Py_None); resultobj = Py_None;
30421 return resultobj;
30422 fail:
30423 return NULL;
30424 }
30425
30426
30427 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30428 PyObject *resultobj;
30429 wxWindow *arg1 = (wxWindow *) 0 ;
30430 int arg2 ;
30431 bool result;
30432 PyObject * obj0 = 0 ;
30433 PyObject * obj1 = 0 ;
30434 char *kwnames[] = {
30435 (char *) "self",(char *) "orient", NULL
30436 };
30437
30438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30440 if (SWIG_arg_fail(1)) SWIG_fail;
30441 {
30442 arg2 = (int)(SWIG_As_int(obj1));
30443 if (SWIG_arg_fail(2)) SWIG_fail;
30444 }
30445 {
30446 PyThreadState* __tstate = wxPyBeginAllowThreads();
30447 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30448
30449 wxPyEndAllowThreads(__tstate);
30450 if (PyErr_Occurred()) SWIG_fail;
30451 }
30452 {
30453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30454 }
30455 return resultobj;
30456 fail:
30457 return NULL;
30458 }
30459
30460
30461 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30462 PyObject *resultobj;
30463 wxWindow *arg1 = (wxWindow *) 0 ;
30464 int arg2 ;
30465 int arg3 ;
30466 int arg4 ;
30467 int arg5 ;
30468 bool arg6 = (bool) true ;
30469 PyObject * obj0 = 0 ;
30470 PyObject * obj1 = 0 ;
30471 PyObject * obj2 = 0 ;
30472 PyObject * obj3 = 0 ;
30473 PyObject * obj4 = 0 ;
30474 PyObject * obj5 = 0 ;
30475 char *kwnames[] = {
30476 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30477 };
30478
30479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30481 if (SWIG_arg_fail(1)) SWIG_fail;
30482 {
30483 arg2 = (int)(SWIG_As_int(obj1));
30484 if (SWIG_arg_fail(2)) SWIG_fail;
30485 }
30486 {
30487 arg3 = (int)(SWIG_As_int(obj2));
30488 if (SWIG_arg_fail(3)) SWIG_fail;
30489 }
30490 {
30491 arg4 = (int)(SWIG_As_int(obj3));
30492 if (SWIG_arg_fail(4)) SWIG_fail;
30493 }
30494 {
30495 arg5 = (int)(SWIG_As_int(obj4));
30496 if (SWIG_arg_fail(5)) SWIG_fail;
30497 }
30498 if (obj5) {
30499 {
30500 arg6 = (bool)(SWIG_As_bool(obj5));
30501 if (SWIG_arg_fail(6)) SWIG_fail;
30502 }
30503 }
30504 {
30505 PyThreadState* __tstate = wxPyBeginAllowThreads();
30506 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30507
30508 wxPyEndAllowThreads(__tstate);
30509 if (PyErr_Occurred()) SWIG_fail;
30510 }
30511 Py_INCREF(Py_None); resultobj = Py_None;
30512 return resultobj;
30513 fail:
30514 return NULL;
30515 }
30516
30517
30518 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30519 PyObject *resultobj;
30520 wxWindow *arg1 = (wxWindow *) 0 ;
30521 int arg2 ;
30522 int arg3 ;
30523 bool arg4 = (bool) true ;
30524 PyObject * obj0 = 0 ;
30525 PyObject * obj1 = 0 ;
30526 PyObject * obj2 = 0 ;
30527 PyObject * obj3 = 0 ;
30528 char *kwnames[] = {
30529 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30530 };
30531
30532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30534 if (SWIG_arg_fail(1)) SWIG_fail;
30535 {
30536 arg2 = (int)(SWIG_As_int(obj1));
30537 if (SWIG_arg_fail(2)) SWIG_fail;
30538 }
30539 {
30540 arg3 = (int)(SWIG_As_int(obj2));
30541 if (SWIG_arg_fail(3)) SWIG_fail;
30542 }
30543 if (obj3) {
30544 {
30545 arg4 = (bool)(SWIG_As_bool(obj3));
30546 if (SWIG_arg_fail(4)) SWIG_fail;
30547 }
30548 }
30549 {
30550 PyThreadState* __tstate = wxPyBeginAllowThreads();
30551 (arg1)->SetScrollPos(arg2,arg3,arg4);
30552
30553 wxPyEndAllowThreads(__tstate);
30554 if (PyErr_Occurred()) SWIG_fail;
30555 }
30556 Py_INCREF(Py_None); resultobj = Py_None;
30557 return resultobj;
30558 fail:
30559 return NULL;
30560 }
30561
30562
30563 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30564 PyObject *resultobj;
30565 wxWindow *arg1 = (wxWindow *) 0 ;
30566 int arg2 ;
30567 int result;
30568 PyObject * obj0 = 0 ;
30569 PyObject * obj1 = 0 ;
30570 char *kwnames[] = {
30571 (char *) "self",(char *) "orientation", NULL
30572 };
30573
30574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30576 if (SWIG_arg_fail(1)) SWIG_fail;
30577 {
30578 arg2 = (int)(SWIG_As_int(obj1));
30579 if (SWIG_arg_fail(2)) SWIG_fail;
30580 }
30581 {
30582 PyThreadState* __tstate = wxPyBeginAllowThreads();
30583 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30584
30585 wxPyEndAllowThreads(__tstate);
30586 if (PyErr_Occurred()) SWIG_fail;
30587 }
30588 {
30589 resultobj = SWIG_From_int((int)(result));
30590 }
30591 return resultobj;
30592 fail:
30593 return NULL;
30594 }
30595
30596
30597 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30598 PyObject *resultobj;
30599 wxWindow *arg1 = (wxWindow *) 0 ;
30600 int arg2 ;
30601 int result;
30602 PyObject * obj0 = 0 ;
30603 PyObject * obj1 = 0 ;
30604 char *kwnames[] = {
30605 (char *) "self",(char *) "orientation", NULL
30606 };
30607
30608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30610 if (SWIG_arg_fail(1)) SWIG_fail;
30611 {
30612 arg2 = (int)(SWIG_As_int(obj1));
30613 if (SWIG_arg_fail(2)) SWIG_fail;
30614 }
30615 {
30616 PyThreadState* __tstate = wxPyBeginAllowThreads();
30617 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
30618
30619 wxPyEndAllowThreads(__tstate);
30620 if (PyErr_Occurred()) SWIG_fail;
30621 }
30622 {
30623 resultobj = SWIG_From_int((int)(result));
30624 }
30625 return resultobj;
30626 fail:
30627 return NULL;
30628 }
30629
30630
30631 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
30632 PyObject *resultobj;
30633 wxWindow *arg1 = (wxWindow *) 0 ;
30634 int arg2 ;
30635 int result;
30636 PyObject * obj0 = 0 ;
30637 PyObject * obj1 = 0 ;
30638 char *kwnames[] = {
30639 (char *) "self",(char *) "orientation", NULL
30640 };
30641
30642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
30643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30644 if (SWIG_arg_fail(1)) SWIG_fail;
30645 {
30646 arg2 = (int)(SWIG_As_int(obj1));
30647 if (SWIG_arg_fail(2)) SWIG_fail;
30648 }
30649 {
30650 PyThreadState* __tstate = wxPyBeginAllowThreads();
30651 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
30652
30653 wxPyEndAllowThreads(__tstate);
30654 if (PyErr_Occurred()) SWIG_fail;
30655 }
30656 {
30657 resultobj = SWIG_From_int((int)(result));
30658 }
30659 return resultobj;
30660 fail:
30661 return NULL;
30662 }
30663
30664
30665 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30666 PyObject *resultobj;
30667 wxWindow *arg1 = (wxWindow *) 0 ;
30668 int arg2 ;
30669 int arg3 ;
30670 wxRect *arg4 = (wxRect *) NULL ;
30671 PyObject * obj0 = 0 ;
30672 PyObject * obj1 = 0 ;
30673 PyObject * obj2 = 0 ;
30674 PyObject * obj3 = 0 ;
30675 char *kwnames[] = {
30676 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
30677 };
30678
30679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30681 if (SWIG_arg_fail(1)) SWIG_fail;
30682 {
30683 arg2 = (int)(SWIG_As_int(obj1));
30684 if (SWIG_arg_fail(2)) SWIG_fail;
30685 }
30686 {
30687 arg3 = (int)(SWIG_As_int(obj2));
30688 if (SWIG_arg_fail(3)) SWIG_fail;
30689 }
30690 if (obj3) {
30691 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30692 if (SWIG_arg_fail(4)) SWIG_fail;
30693 }
30694 {
30695 PyThreadState* __tstate = wxPyBeginAllowThreads();
30696 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
30697
30698 wxPyEndAllowThreads(__tstate);
30699 if (PyErr_Occurred()) SWIG_fail;
30700 }
30701 Py_INCREF(Py_None); resultobj = Py_None;
30702 return resultobj;
30703 fail:
30704 return NULL;
30705 }
30706
30707
30708 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
30709 PyObject *resultobj;
30710 wxWindow *arg1 = (wxWindow *) 0 ;
30711 int arg2 ;
30712 bool result;
30713 PyObject * obj0 = 0 ;
30714 PyObject * obj1 = 0 ;
30715 char *kwnames[] = {
30716 (char *) "self",(char *) "lines", NULL
30717 };
30718
30719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
30720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30721 if (SWIG_arg_fail(1)) SWIG_fail;
30722 {
30723 arg2 = (int)(SWIG_As_int(obj1));
30724 if (SWIG_arg_fail(2)) SWIG_fail;
30725 }
30726 {
30727 PyThreadState* __tstate = wxPyBeginAllowThreads();
30728 result = (bool)(arg1)->ScrollLines(arg2);
30729
30730 wxPyEndAllowThreads(__tstate);
30731 if (PyErr_Occurred()) SWIG_fail;
30732 }
30733 {
30734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30735 }
30736 return resultobj;
30737 fail:
30738 return NULL;
30739 }
30740
30741
30742 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
30743 PyObject *resultobj;
30744 wxWindow *arg1 = (wxWindow *) 0 ;
30745 int arg2 ;
30746 bool result;
30747 PyObject * obj0 = 0 ;
30748 PyObject * obj1 = 0 ;
30749 char *kwnames[] = {
30750 (char *) "self",(char *) "pages", NULL
30751 };
30752
30753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
30754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30755 if (SWIG_arg_fail(1)) SWIG_fail;
30756 {
30757 arg2 = (int)(SWIG_As_int(obj1));
30758 if (SWIG_arg_fail(2)) SWIG_fail;
30759 }
30760 {
30761 PyThreadState* __tstate = wxPyBeginAllowThreads();
30762 result = (bool)(arg1)->ScrollPages(arg2);
30763
30764 wxPyEndAllowThreads(__tstate);
30765 if (PyErr_Occurred()) SWIG_fail;
30766 }
30767 {
30768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30769 }
30770 return resultobj;
30771 fail:
30772 return NULL;
30773 }
30774
30775
30776 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
30777 PyObject *resultobj;
30778 wxWindow *arg1 = (wxWindow *) 0 ;
30779 bool result;
30780 PyObject * obj0 = 0 ;
30781 char *kwnames[] = {
30782 (char *) "self", NULL
30783 };
30784
30785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
30786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30787 if (SWIG_arg_fail(1)) SWIG_fail;
30788 {
30789 PyThreadState* __tstate = wxPyBeginAllowThreads();
30790 result = (bool)(arg1)->LineUp();
30791
30792 wxPyEndAllowThreads(__tstate);
30793 if (PyErr_Occurred()) SWIG_fail;
30794 }
30795 {
30796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30797 }
30798 return resultobj;
30799 fail:
30800 return NULL;
30801 }
30802
30803
30804 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
30805 PyObject *resultobj;
30806 wxWindow *arg1 = (wxWindow *) 0 ;
30807 bool result;
30808 PyObject * obj0 = 0 ;
30809 char *kwnames[] = {
30810 (char *) "self", NULL
30811 };
30812
30813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
30814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30815 if (SWIG_arg_fail(1)) SWIG_fail;
30816 {
30817 PyThreadState* __tstate = wxPyBeginAllowThreads();
30818 result = (bool)(arg1)->LineDown();
30819
30820 wxPyEndAllowThreads(__tstate);
30821 if (PyErr_Occurred()) SWIG_fail;
30822 }
30823 {
30824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30825 }
30826 return resultobj;
30827 fail:
30828 return NULL;
30829 }
30830
30831
30832 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
30833 PyObject *resultobj;
30834 wxWindow *arg1 = (wxWindow *) 0 ;
30835 bool result;
30836 PyObject * obj0 = 0 ;
30837 char *kwnames[] = {
30838 (char *) "self", NULL
30839 };
30840
30841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
30842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30843 if (SWIG_arg_fail(1)) SWIG_fail;
30844 {
30845 PyThreadState* __tstate = wxPyBeginAllowThreads();
30846 result = (bool)(arg1)->PageUp();
30847
30848 wxPyEndAllowThreads(__tstate);
30849 if (PyErr_Occurred()) SWIG_fail;
30850 }
30851 {
30852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30853 }
30854 return resultobj;
30855 fail:
30856 return NULL;
30857 }
30858
30859
30860 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
30861 PyObject *resultobj;
30862 wxWindow *arg1 = (wxWindow *) 0 ;
30863 bool result;
30864 PyObject * obj0 = 0 ;
30865 char *kwnames[] = {
30866 (char *) "self", NULL
30867 };
30868
30869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
30870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30871 if (SWIG_arg_fail(1)) SWIG_fail;
30872 {
30873 PyThreadState* __tstate = wxPyBeginAllowThreads();
30874 result = (bool)(arg1)->PageDown();
30875
30876 wxPyEndAllowThreads(__tstate);
30877 if (PyErr_Occurred()) SWIG_fail;
30878 }
30879 {
30880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30881 }
30882 return resultobj;
30883 fail:
30884 return NULL;
30885 }
30886
30887
30888 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30889 PyObject *resultobj;
30890 wxWindow *arg1 = (wxWindow *) 0 ;
30891 wxString *arg2 = 0 ;
30892 bool temp2 = false ;
30893 PyObject * obj0 = 0 ;
30894 PyObject * obj1 = 0 ;
30895 char *kwnames[] = {
30896 (char *) "self",(char *) "text", NULL
30897 };
30898
30899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
30900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30901 if (SWIG_arg_fail(1)) SWIG_fail;
30902 {
30903 arg2 = wxString_in_helper(obj1);
30904 if (arg2 == NULL) SWIG_fail;
30905 temp2 = true;
30906 }
30907 {
30908 PyThreadState* __tstate = wxPyBeginAllowThreads();
30909 (arg1)->SetHelpText((wxString const &)*arg2);
30910
30911 wxPyEndAllowThreads(__tstate);
30912 if (PyErr_Occurred()) SWIG_fail;
30913 }
30914 Py_INCREF(Py_None); resultobj = Py_None;
30915 {
30916 if (temp2)
30917 delete arg2;
30918 }
30919 return resultobj;
30920 fail:
30921 {
30922 if (temp2)
30923 delete arg2;
30924 }
30925 return NULL;
30926 }
30927
30928
30929 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
30930 PyObject *resultobj;
30931 wxWindow *arg1 = (wxWindow *) 0 ;
30932 wxString *arg2 = 0 ;
30933 bool temp2 = false ;
30934 PyObject * obj0 = 0 ;
30935 PyObject * obj1 = 0 ;
30936 char *kwnames[] = {
30937 (char *) "self",(char *) "text", NULL
30938 };
30939
30940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
30941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30942 if (SWIG_arg_fail(1)) SWIG_fail;
30943 {
30944 arg2 = wxString_in_helper(obj1);
30945 if (arg2 == NULL) SWIG_fail;
30946 temp2 = true;
30947 }
30948 {
30949 PyThreadState* __tstate = wxPyBeginAllowThreads();
30950 (arg1)->SetHelpTextForId((wxString const &)*arg2);
30951
30952 wxPyEndAllowThreads(__tstate);
30953 if (PyErr_Occurred()) SWIG_fail;
30954 }
30955 Py_INCREF(Py_None); resultobj = Py_None;
30956 {
30957 if (temp2)
30958 delete arg2;
30959 }
30960 return resultobj;
30961 fail:
30962 {
30963 if (temp2)
30964 delete arg2;
30965 }
30966 return NULL;
30967 }
30968
30969
30970 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30971 PyObject *resultobj;
30972 wxWindow *arg1 = (wxWindow *) 0 ;
30973 wxString result;
30974 PyObject * obj0 = 0 ;
30975 char *kwnames[] = {
30976 (char *) "self", NULL
30977 };
30978
30979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
30980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30981 if (SWIG_arg_fail(1)) SWIG_fail;
30982 {
30983 PyThreadState* __tstate = wxPyBeginAllowThreads();
30984 result = ((wxWindow const *)arg1)->GetHelpText();
30985
30986 wxPyEndAllowThreads(__tstate);
30987 if (PyErr_Occurred()) SWIG_fail;
30988 }
30989 {
30990 #if wxUSE_UNICODE
30991 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30992 #else
30993 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30994 #endif
30995 }
30996 return resultobj;
30997 fail:
30998 return NULL;
30999 }
31000
31001
31002 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31003 PyObject *resultobj;
31004 wxWindow *arg1 = (wxWindow *) 0 ;
31005 wxString *arg2 = 0 ;
31006 bool temp2 = false ;
31007 PyObject * obj0 = 0 ;
31008 PyObject * obj1 = 0 ;
31009 char *kwnames[] = {
31010 (char *) "self",(char *) "tip", NULL
31011 };
31012
31013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31015 if (SWIG_arg_fail(1)) SWIG_fail;
31016 {
31017 arg2 = wxString_in_helper(obj1);
31018 if (arg2 == NULL) SWIG_fail;
31019 temp2 = true;
31020 }
31021 {
31022 PyThreadState* __tstate = wxPyBeginAllowThreads();
31023 (arg1)->SetToolTip((wxString const &)*arg2);
31024
31025 wxPyEndAllowThreads(__tstate);
31026 if (PyErr_Occurred()) SWIG_fail;
31027 }
31028 Py_INCREF(Py_None); resultobj = Py_None;
31029 {
31030 if (temp2)
31031 delete arg2;
31032 }
31033 return resultobj;
31034 fail:
31035 {
31036 if (temp2)
31037 delete arg2;
31038 }
31039 return NULL;
31040 }
31041
31042
31043 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31044 PyObject *resultobj;
31045 wxWindow *arg1 = (wxWindow *) 0 ;
31046 wxToolTip *arg2 = (wxToolTip *) 0 ;
31047 PyObject * obj0 = 0 ;
31048 PyObject * obj1 = 0 ;
31049 char *kwnames[] = {
31050 (char *) "self",(char *) "tip", NULL
31051 };
31052
31053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31055 if (SWIG_arg_fail(1)) SWIG_fail;
31056 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31057 if (SWIG_arg_fail(2)) SWIG_fail;
31058 {
31059 PyThreadState* __tstate = wxPyBeginAllowThreads();
31060 (arg1)->SetToolTip(arg2);
31061
31062 wxPyEndAllowThreads(__tstate);
31063 if (PyErr_Occurred()) SWIG_fail;
31064 }
31065 Py_INCREF(Py_None); resultobj = Py_None;
31066 return resultobj;
31067 fail:
31068 return NULL;
31069 }
31070
31071
31072 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31073 PyObject *resultobj;
31074 wxWindow *arg1 = (wxWindow *) 0 ;
31075 wxToolTip *result;
31076 PyObject * obj0 = 0 ;
31077 char *kwnames[] = {
31078 (char *) "self", NULL
31079 };
31080
31081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31083 if (SWIG_arg_fail(1)) SWIG_fail;
31084 {
31085 PyThreadState* __tstate = wxPyBeginAllowThreads();
31086 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31087
31088 wxPyEndAllowThreads(__tstate);
31089 if (PyErr_Occurred()) SWIG_fail;
31090 }
31091 {
31092 resultobj = wxPyMake_wxObject(result, 0);
31093 }
31094 return resultobj;
31095 fail:
31096 return NULL;
31097 }
31098
31099
31100 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31101 PyObject *resultobj;
31102 wxWindow *arg1 = (wxWindow *) 0 ;
31103 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31104 PyObject * obj0 = 0 ;
31105 PyObject * obj1 = 0 ;
31106 char *kwnames[] = {
31107 (char *) "self",(char *) "dropTarget", NULL
31108 };
31109
31110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31112 if (SWIG_arg_fail(1)) SWIG_fail;
31113 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31114 if (SWIG_arg_fail(2)) SWIG_fail;
31115 {
31116 PyThreadState* __tstate = wxPyBeginAllowThreads();
31117 (arg1)->SetDropTarget(arg2);
31118
31119 wxPyEndAllowThreads(__tstate);
31120 if (PyErr_Occurred()) SWIG_fail;
31121 }
31122 Py_INCREF(Py_None); resultobj = Py_None;
31123 return resultobj;
31124 fail:
31125 return NULL;
31126 }
31127
31128
31129 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31130 PyObject *resultobj;
31131 wxWindow *arg1 = (wxWindow *) 0 ;
31132 wxPyDropTarget *result;
31133 PyObject * obj0 = 0 ;
31134 char *kwnames[] = {
31135 (char *) "self", NULL
31136 };
31137
31138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31140 if (SWIG_arg_fail(1)) SWIG_fail;
31141 {
31142 PyThreadState* __tstate = wxPyBeginAllowThreads();
31143 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31144
31145 wxPyEndAllowThreads(__tstate);
31146 if (PyErr_Occurred()) SWIG_fail;
31147 }
31148 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31149 return resultobj;
31150 fail:
31151 return NULL;
31152 }
31153
31154
31155 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31156 PyObject *resultobj;
31157 wxWindow *arg1 = (wxWindow *) 0 ;
31158 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31159 PyObject * obj0 = 0 ;
31160 PyObject * obj1 = 0 ;
31161 char *kwnames[] = {
31162 (char *) "self",(char *) "constraints", NULL
31163 };
31164
31165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31167 if (SWIG_arg_fail(1)) SWIG_fail;
31168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31169 if (SWIG_arg_fail(2)) SWIG_fail;
31170 {
31171 PyThreadState* __tstate = wxPyBeginAllowThreads();
31172 (arg1)->SetConstraints(arg2);
31173
31174 wxPyEndAllowThreads(__tstate);
31175 if (PyErr_Occurred()) SWIG_fail;
31176 }
31177 Py_INCREF(Py_None); resultobj = Py_None;
31178 return resultobj;
31179 fail:
31180 return NULL;
31181 }
31182
31183
31184 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31185 PyObject *resultobj;
31186 wxWindow *arg1 = (wxWindow *) 0 ;
31187 wxLayoutConstraints *result;
31188 PyObject * obj0 = 0 ;
31189 char *kwnames[] = {
31190 (char *) "self", NULL
31191 };
31192
31193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31195 if (SWIG_arg_fail(1)) SWIG_fail;
31196 {
31197 PyThreadState* __tstate = wxPyBeginAllowThreads();
31198 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31199
31200 wxPyEndAllowThreads(__tstate);
31201 if (PyErr_Occurred()) SWIG_fail;
31202 }
31203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31204 return resultobj;
31205 fail:
31206 return NULL;
31207 }
31208
31209
31210 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31211 PyObject *resultobj;
31212 wxWindow *arg1 = (wxWindow *) 0 ;
31213 bool arg2 ;
31214 PyObject * obj0 = 0 ;
31215 PyObject * obj1 = 0 ;
31216 char *kwnames[] = {
31217 (char *) "self",(char *) "autoLayout", NULL
31218 };
31219
31220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31222 if (SWIG_arg_fail(1)) SWIG_fail;
31223 {
31224 arg2 = (bool)(SWIG_As_bool(obj1));
31225 if (SWIG_arg_fail(2)) SWIG_fail;
31226 }
31227 {
31228 PyThreadState* __tstate = wxPyBeginAllowThreads();
31229 (arg1)->SetAutoLayout(arg2);
31230
31231 wxPyEndAllowThreads(__tstate);
31232 if (PyErr_Occurred()) SWIG_fail;
31233 }
31234 Py_INCREF(Py_None); resultobj = Py_None;
31235 return resultobj;
31236 fail:
31237 return NULL;
31238 }
31239
31240
31241 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31242 PyObject *resultobj;
31243 wxWindow *arg1 = (wxWindow *) 0 ;
31244 bool result;
31245 PyObject * obj0 = 0 ;
31246 char *kwnames[] = {
31247 (char *) "self", NULL
31248 };
31249
31250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31252 if (SWIG_arg_fail(1)) SWIG_fail;
31253 {
31254 PyThreadState* __tstate = wxPyBeginAllowThreads();
31255 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31256
31257 wxPyEndAllowThreads(__tstate);
31258 if (PyErr_Occurred()) SWIG_fail;
31259 }
31260 {
31261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31262 }
31263 return resultobj;
31264 fail:
31265 return NULL;
31266 }
31267
31268
31269 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31270 PyObject *resultobj;
31271 wxWindow *arg1 = (wxWindow *) 0 ;
31272 bool result;
31273 PyObject * obj0 = 0 ;
31274 char *kwnames[] = {
31275 (char *) "self", NULL
31276 };
31277
31278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31280 if (SWIG_arg_fail(1)) SWIG_fail;
31281 {
31282 PyThreadState* __tstate = wxPyBeginAllowThreads();
31283 result = (bool)(arg1)->Layout();
31284
31285 wxPyEndAllowThreads(__tstate);
31286 if (PyErr_Occurred()) SWIG_fail;
31287 }
31288 {
31289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31290 }
31291 return resultobj;
31292 fail:
31293 return NULL;
31294 }
31295
31296
31297 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31298 PyObject *resultobj;
31299 wxWindow *arg1 = (wxWindow *) 0 ;
31300 wxSizer *arg2 = (wxSizer *) 0 ;
31301 bool arg3 = (bool) true ;
31302 PyObject * obj0 = 0 ;
31303 PyObject * obj1 = 0 ;
31304 PyObject * obj2 = 0 ;
31305 char *kwnames[] = {
31306 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31307 };
31308
31309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31311 if (SWIG_arg_fail(1)) SWIG_fail;
31312 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31313 if (SWIG_arg_fail(2)) SWIG_fail;
31314 if (obj2) {
31315 {
31316 arg3 = (bool)(SWIG_As_bool(obj2));
31317 if (SWIG_arg_fail(3)) SWIG_fail;
31318 }
31319 }
31320 {
31321 PyThreadState* __tstate = wxPyBeginAllowThreads();
31322 (arg1)->SetSizer(arg2,arg3);
31323
31324 wxPyEndAllowThreads(__tstate);
31325 if (PyErr_Occurred()) SWIG_fail;
31326 }
31327 Py_INCREF(Py_None); resultobj = Py_None;
31328 return resultobj;
31329 fail:
31330 return NULL;
31331 }
31332
31333
31334 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31335 PyObject *resultobj;
31336 wxWindow *arg1 = (wxWindow *) 0 ;
31337 wxSizer *arg2 = (wxSizer *) 0 ;
31338 bool arg3 = (bool) true ;
31339 PyObject * obj0 = 0 ;
31340 PyObject * obj1 = 0 ;
31341 PyObject * obj2 = 0 ;
31342 char *kwnames[] = {
31343 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31344 };
31345
31346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31348 if (SWIG_arg_fail(1)) SWIG_fail;
31349 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31350 if (SWIG_arg_fail(2)) SWIG_fail;
31351 if (obj2) {
31352 {
31353 arg3 = (bool)(SWIG_As_bool(obj2));
31354 if (SWIG_arg_fail(3)) SWIG_fail;
31355 }
31356 }
31357 {
31358 PyThreadState* __tstate = wxPyBeginAllowThreads();
31359 (arg1)->SetSizerAndFit(arg2,arg3);
31360
31361 wxPyEndAllowThreads(__tstate);
31362 if (PyErr_Occurred()) SWIG_fail;
31363 }
31364 Py_INCREF(Py_None); resultobj = Py_None;
31365 return resultobj;
31366 fail:
31367 return NULL;
31368 }
31369
31370
31371 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31372 PyObject *resultobj;
31373 wxWindow *arg1 = (wxWindow *) 0 ;
31374 wxSizer *result;
31375 PyObject * obj0 = 0 ;
31376 char *kwnames[] = {
31377 (char *) "self", NULL
31378 };
31379
31380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31382 if (SWIG_arg_fail(1)) SWIG_fail;
31383 {
31384 PyThreadState* __tstate = wxPyBeginAllowThreads();
31385 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31386
31387 wxPyEndAllowThreads(__tstate);
31388 if (PyErr_Occurred()) SWIG_fail;
31389 }
31390 {
31391 resultobj = wxPyMake_wxSizer(result, 0);
31392 }
31393 return resultobj;
31394 fail:
31395 return NULL;
31396 }
31397
31398
31399 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31400 PyObject *resultobj;
31401 wxWindow *arg1 = (wxWindow *) 0 ;
31402 wxSizer *arg2 = (wxSizer *) 0 ;
31403 PyObject * obj0 = 0 ;
31404 PyObject * obj1 = 0 ;
31405 char *kwnames[] = {
31406 (char *) "self",(char *) "sizer", NULL
31407 };
31408
31409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31411 if (SWIG_arg_fail(1)) SWIG_fail;
31412 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31413 if (SWIG_arg_fail(2)) SWIG_fail;
31414 {
31415 PyThreadState* __tstate = wxPyBeginAllowThreads();
31416 (arg1)->SetContainingSizer(arg2);
31417
31418 wxPyEndAllowThreads(__tstate);
31419 if (PyErr_Occurred()) SWIG_fail;
31420 }
31421 Py_INCREF(Py_None); resultobj = Py_None;
31422 return resultobj;
31423 fail:
31424 return NULL;
31425 }
31426
31427
31428 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31429 PyObject *resultobj;
31430 wxWindow *arg1 = (wxWindow *) 0 ;
31431 wxSizer *result;
31432 PyObject * obj0 = 0 ;
31433 char *kwnames[] = {
31434 (char *) "self", NULL
31435 };
31436
31437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31439 if (SWIG_arg_fail(1)) SWIG_fail;
31440 {
31441 PyThreadState* __tstate = wxPyBeginAllowThreads();
31442 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31443
31444 wxPyEndAllowThreads(__tstate);
31445 if (PyErr_Occurred()) SWIG_fail;
31446 }
31447 {
31448 resultobj = wxPyMake_wxSizer(result, 0);
31449 }
31450 return resultobj;
31451 fail:
31452 return NULL;
31453 }
31454
31455
31456 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31457 PyObject *resultobj;
31458 wxWindow *arg1 = (wxWindow *) 0 ;
31459 PyObject * obj0 = 0 ;
31460 char *kwnames[] = {
31461 (char *) "self", NULL
31462 };
31463
31464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31466 if (SWIG_arg_fail(1)) SWIG_fail;
31467 {
31468 PyThreadState* __tstate = wxPyBeginAllowThreads();
31469 (arg1)->InheritAttributes();
31470
31471 wxPyEndAllowThreads(__tstate);
31472 if (PyErr_Occurred()) SWIG_fail;
31473 }
31474 Py_INCREF(Py_None); resultobj = Py_None;
31475 return resultobj;
31476 fail:
31477 return NULL;
31478 }
31479
31480
31481 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31482 PyObject *resultobj;
31483 wxWindow *arg1 = (wxWindow *) 0 ;
31484 bool result;
31485 PyObject * obj0 = 0 ;
31486 char *kwnames[] = {
31487 (char *) "self", NULL
31488 };
31489
31490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31492 if (SWIG_arg_fail(1)) SWIG_fail;
31493 {
31494 PyThreadState* __tstate = wxPyBeginAllowThreads();
31495 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31496
31497 wxPyEndAllowThreads(__tstate);
31498 if (PyErr_Occurred()) SWIG_fail;
31499 }
31500 {
31501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31502 }
31503 return resultobj;
31504 fail:
31505 return NULL;
31506 }
31507
31508
31509 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31510 PyObject *obj;
31511 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31512 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31513 Py_INCREF(obj);
31514 return Py_BuildValue((char *)"");
31515 }
31516 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31517 PyObject *resultobj;
31518 long arg1 ;
31519 wxWindow *arg2 = (wxWindow *) NULL ;
31520 wxWindow *result;
31521 PyObject * obj0 = 0 ;
31522 PyObject * obj1 = 0 ;
31523 char *kwnames[] = {
31524 (char *) "id",(char *) "parent", NULL
31525 };
31526
31527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31528 {
31529 arg1 = (long)(SWIG_As_long(obj0));
31530 if (SWIG_arg_fail(1)) SWIG_fail;
31531 }
31532 if (obj1) {
31533 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31534 if (SWIG_arg_fail(2)) SWIG_fail;
31535 }
31536 {
31537 if (!wxPyCheckForApp()) SWIG_fail;
31538 PyThreadState* __tstate = wxPyBeginAllowThreads();
31539 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31540
31541 wxPyEndAllowThreads(__tstate);
31542 if (PyErr_Occurred()) SWIG_fail;
31543 }
31544 {
31545 resultobj = wxPyMake_wxObject(result, 0);
31546 }
31547 return resultobj;
31548 fail:
31549 return NULL;
31550 }
31551
31552
31553 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31554 PyObject *resultobj;
31555 wxString *arg1 = 0 ;
31556 wxWindow *arg2 = (wxWindow *) NULL ;
31557 wxWindow *result;
31558 bool temp1 = false ;
31559 PyObject * obj0 = 0 ;
31560 PyObject * obj1 = 0 ;
31561 char *kwnames[] = {
31562 (char *) "name",(char *) "parent", NULL
31563 };
31564
31565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31566 {
31567 arg1 = wxString_in_helper(obj0);
31568 if (arg1 == NULL) SWIG_fail;
31569 temp1 = true;
31570 }
31571 if (obj1) {
31572 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31573 if (SWIG_arg_fail(2)) SWIG_fail;
31574 }
31575 {
31576 if (!wxPyCheckForApp()) SWIG_fail;
31577 PyThreadState* __tstate = wxPyBeginAllowThreads();
31578 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31579
31580 wxPyEndAllowThreads(__tstate);
31581 if (PyErr_Occurred()) SWIG_fail;
31582 }
31583 {
31584 resultobj = wxPyMake_wxObject(result, 0);
31585 }
31586 {
31587 if (temp1)
31588 delete arg1;
31589 }
31590 return resultobj;
31591 fail:
31592 {
31593 if (temp1)
31594 delete arg1;
31595 }
31596 return NULL;
31597 }
31598
31599
31600 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
31601 PyObject *resultobj;
31602 wxString *arg1 = 0 ;
31603 wxWindow *arg2 = (wxWindow *) NULL ;
31604 wxWindow *result;
31605 bool temp1 = false ;
31606 PyObject * obj0 = 0 ;
31607 PyObject * obj1 = 0 ;
31608 char *kwnames[] = {
31609 (char *) "label",(char *) "parent", NULL
31610 };
31611
31612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
31613 {
31614 arg1 = wxString_in_helper(obj0);
31615 if (arg1 == NULL) SWIG_fail;
31616 temp1 = true;
31617 }
31618 if (obj1) {
31619 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31620 if (SWIG_arg_fail(2)) SWIG_fail;
31621 }
31622 {
31623 if (!wxPyCheckForApp()) SWIG_fail;
31624 PyThreadState* __tstate = wxPyBeginAllowThreads();
31625 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
31626
31627 wxPyEndAllowThreads(__tstate);
31628 if (PyErr_Occurred()) SWIG_fail;
31629 }
31630 {
31631 resultobj = wxPyMake_wxObject(result, 0);
31632 }
31633 {
31634 if (temp1)
31635 delete arg1;
31636 }
31637 return resultobj;
31638 fail:
31639 {
31640 if (temp1)
31641 delete arg1;
31642 }
31643 return NULL;
31644 }
31645
31646
31647 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
31648 PyObject *resultobj;
31649 wxWindow *arg1 = (wxWindow *) 0 ;
31650 unsigned long arg2 ;
31651 wxWindow *result;
31652 PyObject * obj0 = 0 ;
31653 PyObject * obj1 = 0 ;
31654 char *kwnames[] = {
31655 (char *) "parent",(char *) "_hWnd", NULL
31656 };
31657
31658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
31659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31660 if (SWIG_arg_fail(1)) SWIG_fail;
31661 {
31662 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
31663 if (SWIG_arg_fail(2)) SWIG_fail;
31664 }
31665 {
31666 PyThreadState* __tstate = wxPyBeginAllowThreads();
31667 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
31668
31669 wxPyEndAllowThreads(__tstate);
31670 if (PyErr_Occurred()) SWIG_fail;
31671 }
31672 {
31673 resultobj = wxPyMake_wxObject(result, 0);
31674 }
31675 return resultobj;
31676 fail:
31677 return NULL;
31678 }
31679
31680
31681 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
31682 PyObject *resultobj;
31683 wxValidator *result;
31684 char *kwnames[] = {
31685 NULL
31686 };
31687
31688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
31689 {
31690 PyThreadState* __tstate = wxPyBeginAllowThreads();
31691 result = (wxValidator *)new wxValidator();
31692
31693 wxPyEndAllowThreads(__tstate);
31694 if (PyErr_Occurred()) SWIG_fail;
31695 }
31696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
31697 return resultobj;
31698 fail:
31699 return NULL;
31700 }
31701
31702
31703 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
31704 PyObject *resultobj;
31705 wxValidator *arg1 = (wxValidator *) 0 ;
31706 wxValidator *result;
31707 PyObject * obj0 = 0 ;
31708 char *kwnames[] = {
31709 (char *) "self", NULL
31710 };
31711
31712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
31713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31714 if (SWIG_arg_fail(1)) SWIG_fail;
31715 {
31716 PyThreadState* __tstate = wxPyBeginAllowThreads();
31717 result = (wxValidator *)(arg1)->Clone();
31718
31719 wxPyEndAllowThreads(__tstate);
31720 if (PyErr_Occurred()) SWIG_fail;
31721 }
31722 {
31723 resultobj = wxPyMake_wxObject(result, 0);
31724 }
31725 return resultobj;
31726 fail:
31727 return NULL;
31728 }
31729
31730
31731 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
31732 PyObject *resultobj;
31733 wxValidator *arg1 = (wxValidator *) 0 ;
31734 wxWindow *arg2 = (wxWindow *) 0 ;
31735 bool result;
31736 PyObject * obj0 = 0 ;
31737 PyObject * obj1 = 0 ;
31738 char *kwnames[] = {
31739 (char *) "self",(char *) "parent", NULL
31740 };
31741
31742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
31743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31744 if (SWIG_arg_fail(1)) SWIG_fail;
31745 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31746 if (SWIG_arg_fail(2)) SWIG_fail;
31747 {
31748 PyThreadState* __tstate = wxPyBeginAllowThreads();
31749 result = (bool)(arg1)->Validate(arg2);
31750
31751 wxPyEndAllowThreads(__tstate);
31752 if (PyErr_Occurred()) SWIG_fail;
31753 }
31754 {
31755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31756 }
31757 return resultobj;
31758 fail:
31759 return NULL;
31760 }
31761
31762
31763 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31764 PyObject *resultobj;
31765 wxValidator *arg1 = (wxValidator *) 0 ;
31766 bool result;
31767 PyObject * obj0 = 0 ;
31768 char *kwnames[] = {
31769 (char *) "self", NULL
31770 };
31771
31772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
31773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31774 if (SWIG_arg_fail(1)) SWIG_fail;
31775 {
31776 PyThreadState* __tstate = wxPyBeginAllowThreads();
31777 result = (bool)(arg1)->TransferToWindow();
31778
31779 wxPyEndAllowThreads(__tstate);
31780 if (PyErr_Occurred()) SWIG_fail;
31781 }
31782 {
31783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31784 }
31785 return resultobj;
31786 fail:
31787 return NULL;
31788 }
31789
31790
31791 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31792 PyObject *resultobj;
31793 wxValidator *arg1 = (wxValidator *) 0 ;
31794 bool result;
31795 PyObject * obj0 = 0 ;
31796 char *kwnames[] = {
31797 (char *) "self", NULL
31798 };
31799
31800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
31801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31802 if (SWIG_arg_fail(1)) SWIG_fail;
31803 {
31804 PyThreadState* __tstate = wxPyBeginAllowThreads();
31805 result = (bool)(arg1)->TransferFromWindow();
31806
31807 wxPyEndAllowThreads(__tstate);
31808 if (PyErr_Occurred()) SWIG_fail;
31809 }
31810 {
31811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31812 }
31813 return resultobj;
31814 fail:
31815 return NULL;
31816 }
31817
31818
31819 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31820 PyObject *resultobj;
31821 wxValidator *arg1 = (wxValidator *) 0 ;
31822 wxWindow *result;
31823 PyObject * obj0 = 0 ;
31824 char *kwnames[] = {
31825 (char *) "self", NULL
31826 };
31827
31828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
31829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31830 if (SWIG_arg_fail(1)) SWIG_fail;
31831 {
31832 PyThreadState* __tstate = wxPyBeginAllowThreads();
31833 result = (wxWindow *)(arg1)->GetWindow();
31834
31835 wxPyEndAllowThreads(__tstate);
31836 if (PyErr_Occurred()) SWIG_fail;
31837 }
31838 {
31839 resultobj = wxPyMake_wxObject(result, 0);
31840 }
31841 return resultobj;
31842 fail:
31843 return NULL;
31844 }
31845
31846
31847 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31848 PyObject *resultobj;
31849 wxValidator *arg1 = (wxValidator *) 0 ;
31850 wxWindow *arg2 = (wxWindow *) 0 ;
31851 PyObject * obj0 = 0 ;
31852 PyObject * obj1 = 0 ;
31853 char *kwnames[] = {
31854 (char *) "self",(char *) "window", NULL
31855 };
31856
31857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
31858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31859 if (SWIG_arg_fail(1)) SWIG_fail;
31860 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31861 if (SWIG_arg_fail(2)) SWIG_fail;
31862 {
31863 PyThreadState* __tstate = wxPyBeginAllowThreads();
31864 (arg1)->SetWindow(arg2);
31865
31866 wxPyEndAllowThreads(__tstate);
31867 if (PyErr_Occurred()) SWIG_fail;
31868 }
31869 Py_INCREF(Py_None); resultobj = Py_None;
31870 return resultobj;
31871 fail:
31872 return NULL;
31873 }
31874
31875
31876 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
31877 PyObject *resultobj;
31878 bool result;
31879 char *kwnames[] = {
31880 NULL
31881 };
31882
31883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
31884 {
31885 PyThreadState* __tstate = wxPyBeginAllowThreads();
31886 result = (bool)wxValidator::IsSilent();
31887
31888 wxPyEndAllowThreads(__tstate);
31889 if (PyErr_Occurred()) SWIG_fail;
31890 }
31891 {
31892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31893 }
31894 return resultobj;
31895 fail:
31896 return NULL;
31897 }
31898
31899
31900 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
31901 PyObject *resultobj;
31902 int arg1 = (int) true ;
31903 PyObject * obj0 = 0 ;
31904 char *kwnames[] = {
31905 (char *) "doIt", NULL
31906 };
31907
31908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
31909 if (obj0) {
31910 {
31911 arg1 = (int)(SWIG_As_int(obj0));
31912 if (SWIG_arg_fail(1)) SWIG_fail;
31913 }
31914 }
31915 {
31916 PyThreadState* __tstate = wxPyBeginAllowThreads();
31917 wxValidator::SetBellOnError(arg1);
31918
31919 wxPyEndAllowThreads(__tstate);
31920 if (PyErr_Occurred()) SWIG_fail;
31921 }
31922 Py_INCREF(Py_None); resultobj = Py_None;
31923 return resultobj;
31924 fail:
31925 return NULL;
31926 }
31927
31928
31929 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
31930 PyObject *obj;
31931 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31932 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
31933 Py_INCREF(obj);
31934 return Py_BuildValue((char *)"");
31935 }
31936 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
31937 PyObject *resultobj;
31938 wxPyValidator *result;
31939 char *kwnames[] = {
31940 NULL
31941 };
31942
31943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
31944 {
31945 PyThreadState* __tstate = wxPyBeginAllowThreads();
31946 result = (wxPyValidator *)new wxPyValidator();
31947
31948 wxPyEndAllowThreads(__tstate);
31949 if (PyErr_Occurred()) SWIG_fail;
31950 }
31951 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
31952 return resultobj;
31953 fail:
31954 return NULL;
31955 }
31956
31957
31958 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
31959 PyObject *resultobj;
31960 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
31961 PyObject *arg2 = (PyObject *) 0 ;
31962 PyObject *arg3 = (PyObject *) 0 ;
31963 int arg4 = (int) true ;
31964 PyObject * obj0 = 0 ;
31965 PyObject * obj1 = 0 ;
31966 PyObject * obj2 = 0 ;
31967 PyObject * obj3 = 0 ;
31968 char *kwnames[] = {
31969 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
31970 };
31971
31972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
31974 if (SWIG_arg_fail(1)) SWIG_fail;
31975 arg2 = obj1;
31976 arg3 = obj2;
31977 if (obj3) {
31978 {
31979 arg4 = (int)(SWIG_As_int(obj3));
31980 if (SWIG_arg_fail(4)) SWIG_fail;
31981 }
31982 }
31983 {
31984 PyThreadState* __tstate = wxPyBeginAllowThreads();
31985 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
31986
31987 wxPyEndAllowThreads(__tstate);
31988 if (PyErr_Occurred()) SWIG_fail;
31989 }
31990 Py_INCREF(Py_None); resultobj = Py_None;
31991 return resultobj;
31992 fail:
31993 return NULL;
31994 }
31995
31996
31997 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
31998 PyObject *obj;
31999 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32000 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32001 Py_INCREF(obj);
32002 return Py_BuildValue((char *)"");
32003 }
32004 static int _wrap_DefaultValidator_set(PyObject *) {
32005 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32006 return 1;
32007 }
32008
32009
32010 static PyObject *_wrap_DefaultValidator_get(void) {
32011 PyObject *pyobj;
32012
32013 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32014 return pyobj;
32015 }
32016
32017
32018 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32019 PyObject *resultobj;
32020 wxString const &arg1_defvalue = wxPyEmptyString ;
32021 wxString *arg1 = (wxString *) &arg1_defvalue ;
32022 long arg2 = (long) 0 ;
32023 wxMenu *result;
32024 bool temp1 = false ;
32025 PyObject * obj0 = 0 ;
32026 PyObject * obj1 = 0 ;
32027 char *kwnames[] = {
32028 (char *) "title",(char *) "style", NULL
32029 };
32030
32031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32032 if (obj0) {
32033 {
32034 arg1 = wxString_in_helper(obj0);
32035 if (arg1 == NULL) SWIG_fail;
32036 temp1 = true;
32037 }
32038 }
32039 if (obj1) {
32040 {
32041 arg2 = (long)(SWIG_As_long(obj1));
32042 if (SWIG_arg_fail(2)) SWIG_fail;
32043 }
32044 }
32045 {
32046 if (!wxPyCheckForApp()) SWIG_fail;
32047 PyThreadState* __tstate = wxPyBeginAllowThreads();
32048 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32049
32050 wxPyEndAllowThreads(__tstate);
32051 if (PyErr_Occurred()) SWIG_fail;
32052 }
32053 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32054 {
32055 if (temp1)
32056 delete arg1;
32057 }
32058 return resultobj;
32059 fail:
32060 {
32061 if (temp1)
32062 delete arg1;
32063 }
32064 return NULL;
32065 }
32066
32067
32068 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32069 PyObject *resultobj;
32070 wxMenu *arg1 = (wxMenu *) 0 ;
32071 int arg2 ;
32072 wxString *arg3 = 0 ;
32073 wxString const &arg4_defvalue = wxPyEmptyString ;
32074 wxString *arg4 = (wxString *) &arg4_defvalue ;
32075 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32076 wxMenuItem *result;
32077 bool temp3 = false ;
32078 bool temp4 = false ;
32079 PyObject * obj0 = 0 ;
32080 PyObject * obj1 = 0 ;
32081 PyObject * obj2 = 0 ;
32082 PyObject * obj3 = 0 ;
32083 PyObject * obj4 = 0 ;
32084 char *kwnames[] = {
32085 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32086 };
32087
32088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32090 if (SWIG_arg_fail(1)) SWIG_fail;
32091 {
32092 arg2 = (int)(SWIG_As_int(obj1));
32093 if (SWIG_arg_fail(2)) SWIG_fail;
32094 }
32095 {
32096 arg3 = wxString_in_helper(obj2);
32097 if (arg3 == NULL) SWIG_fail;
32098 temp3 = true;
32099 }
32100 if (obj3) {
32101 {
32102 arg4 = wxString_in_helper(obj3);
32103 if (arg4 == NULL) SWIG_fail;
32104 temp4 = true;
32105 }
32106 }
32107 if (obj4) {
32108 {
32109 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32110 if (SWIG_arg_fail(5)) SWIG_fail;
32111 }
32112 }
32113 {
32114 PyThreadState* __tstate = wxPyBeginAllowThreads();
32115 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32116
32117 wxPyEndAllowThreads(__tstate);
32118 if (PyErr_Occurred()) SWIG_fail;
32119 }
32120 {
32121 resultobj = wxPyMake_wxObject(result, 0);
32122 }
32123 {
32124 if (temp3)
32125 delete arg3;
32126 }
32127 {
32128 if (temp4)
32129 delete arg4;
32130 }
32131 return resultobj;
32132 fail:
32133 {
32134 if (temp3)
32135 delete arg3;
32136 }
32137 {
32138 if (temp4)
32139 delete arg4;
32140 }
32141 return NULL;
32142 }
32143
32144
32145 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32146 PyObject *resultobj;
32147 wxMenu *arg1 = (wxMenu *) 0 ;
32148 wxMenuItem *result;
32149 PyObject * obj0 = 0 ;
32150 char *kwnames[] = {
32151 (char *) "self", NULL
32152 };
32153
32154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32156 if (SWIG_arg_fail(1)) SWIG_fail;
32157 {
32158 PyThreadState* __tstate = wxPyBeginAllowThreads();
32159 result = (wxMenuItem *)(arg1)->AppendSeparator();
32160
32161 wxPyEndAllowThreads(__tstate);
32162 if (PyErr_Occurred()) SWIG_fail;
32163 }
32164 {
32165 resultobj = wxPyMake_wxObject(result, 0);
32166 }
32167 return resultobj;
32168 fail:
32169 return NULL;
32170 }
32171
32172
32173 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32174 PyObject *resultobj;
32175 wxMenu *arg1 = (wxMenu *) 0 ;
32176 int arg2 ;
32177 wxString *arg3 = 0 ;
32178 wxString const &arg4_defvalue = wxPyEmptyString ;
32179 wxString *arg4 = (wxString *) &arg4_defvalue ;
32180 wxMenuItem *result;
32181 bool temp3 = false ;
32182 bool temp4 = false ;
32183 PyObject * obj0 = 0 ;
32184 PyObject * obj1 = 0 ;
32185 PyObject * obj2 = 0 ;
32186 PyObject * obj3 = 0 ;
32187 char *kwnames[] = {
32188 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32189 };
32190
32191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32193 if (SWIG_arg_fail(1)) SWIG_fail;
32194 {
32195 arg2 = (int)(SWIG_As_int(obj1));
32196 if (SWIG_arg_fail(2)) SWIG_fail;
32197 }
32198 {
32199 arg3 = wxString_in_helper(obj2);
32200 if (arg3 == NULL) SWIG_fail;
32201 temp3 = true;
32202 }
32203 if (obj3) {
32204 {
32205 arg4 = wxString_in_helper(obj3);
32206 if (arg4 == NULL) SWIG_fail;
32207 temp4 = true;
32208 }
32209 }
32210 {
32211 PyThreadState* __tstate = wxPyBeginAllowThreads();
32212 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32213
32214 wxPyEndAllowThreads(__tstate);
32215 if (PyErr_Occurred()) SWIG_fail;
32216 }
32217 {
32218 resultobj = wxPyMake_wxObject(result, 0);
32219 }
32220 {
32221 if (temp3)
32222 delete arg3;
32223 }
32224 {
32225 if (temp4)
32226 delete arg4;
32227 }
32228 return resultobj;
32229 fail:
32230 {
32231 if (temp3)
32232 delete arg3;
32233 }
32234 {
32235 if (temp4)
32236 delete arg4;
32237 }
32238 return NULL;
32239 }
32240
32241
32242 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32243 PyObject *resultobj;
32244 wxMenu *arg1 = (wxMenu *) 0 ;
32245 int arg2 ;
32246 wxString *arg3 = 0 ;
32247 wxString const &arg4_defvalue = wxPyEmptyString ;
32248 wxString *arg4 = (wxString *) &arg4_defvalue ;
32249 wxMenuItem *result;
32250 bool temp3 = false ;
32251 bool temp4 = false ;
32252 PyObject * obj0 = 0 ;
32253 PyObject * obj1 = 0 ;
32254 PyObject * obj2 = 0 ;
32255 PyObject * obj3 = 0 ;
32256 char *kwnames[] = {
32257 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32258 };
32259
32260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32262 if (SWIG_arg_fail(1)) SWIG_fail;
32263 {
32264 arg2 = (int)(SWIG_As_int(obj1));
32265 if (SWIG_arg_fail(2)) SWIG_fail;
32266 }
32267 {
32268 arg3 = wxString_in_helper(obj2);
32269 if (arg3 == NULL) SWIG_fail;
32270 temp3 = true;
32271 }
32272 if (obj3) {
32273 {
32274 arg4 = wxString_in_helper(obj3);
32275 if (arg4 == NULL) SWIG_fail;
32276 temp4 = true;
32277 }
32278 }
32279 {
32280 PyThreadState* __tstate = wxPyBeginAllowThreads();
32281 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32282
32283 wxPyEndAllowThreads(__tstate);
32284 if (PyErr_Occurred()) SWIG_fail;
32285 }
32286 {
32287 resultobj = wxPyMake_wxObject(result, 0);
32288 }
32289 {
32290 if (temp3)
32291 delete arg3;
32292 }
32293 {
32294 if (temp4)
32295 delete arg4;
32296 }
32297 return resultobj;
32298 fail:
32299 {
32300 if (temp3)
32301 delete arg3;
32302 }
32303 {
32304 if (temp4)
32305 delete arg4;
32306 }
32307 return NULL;
32308 }
32309
32310
32311 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32312 PyObject *resultobj;
32313 wxMenu *arg1 = (wxMenu *) 0 ;
32314 int arg2 ;
32315 wxString *arg3 = 0 ;
32316 wxMenu *arg4 = (wxMenu *) 0 ;
32317 wxString const &arg5_defvalue = wxPyEmptyString ;
32318 wxString *arg5 = (wxString *) &arg5_defvalue ;
32319 wxMenuItem *result;
32320 bool temp3 = false ;
32321 bool temp5 = false ;
32322 PyObject * obj0 = 0 ;
32323 PyObject * obj1 = 0 ;
32324 PyObject * obj2 = 0 ;
32325 PyObject * obj3 = 0 ;
32326 PyObject * obj4 = 0 ;
32327 char *kwnames[] = {
32328 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32329 };
32330
32331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32333 if (SWIG_arg_fail(1)) SWIG_fail;
32334 {
32335 arg2 = (int)(SWIG_As_int(obj1));
32336 if (SWIG_arg_fail(2)) SWIG_fail;
32337 }
32338 {
32339 arg3 = wxString_in_helper(obj2);
32340 if (arg3 == NULL) SWIG_fail;
32341 temp3 = true;
32342 }
32343 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32344 if (SWIG_arg_fail(4)) SWIG_fail;
32345 if (obj4) {
32346 {
32347 arg5 = wxString_in_helper(obj4);
32348 if (arg5 == NULL) SWIG_fail;
32349 temp5 = true;
32350 }
32351 }
32352 {
32353 PyThreadState* __tstate = wxPyBeginAllowThreads();
32354 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32355
32356 wxPyEndAllowThreads(__tstate);
32357 if (PyErr_Occurred()) SWIG_fail;
32358 }
32359 {
32360 resultobj = wxPyMake_wxObject(result, 0);
32361 }
32362 {
32363 if (temp3)
32364 delete arg3;
32365 }
32366 {
32367 if (temp5)
32368 delete arg5;
32369 }
32370 return resultobj;
32371 fail:
32372 {
32373 if (temp3)
32374 delete arg3;
32375 }
32376 {
32377 if (temp5)
32378 delete arg5;
32379 }
32380 return NULL;
32381 }
32382
32383
32384 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32385 PyObject *resultobj;
32386 wxMenu *arg1 = (wxMenu *) 0 ;
32387 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32388 wxMenuItem *result;
32389 PyObject * obj0 = 0 ;
32390 PyObject * obj1 = 0 ;
32391 char *kwnames[] = {
32392 (char *) "self",(char *) "item", NULL
32393 };
32394
32395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32397 if (SWIG_arg_fail(1)) SWIG_fail;
32398 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32399 if (SWIG_arg_fail(2)) SWIG_fail;
32400 {
32401 PyThreadState* __tstate = wxPyBeginAllowThreads();
32402 result = (wxMenuItem *)(arg1)->Append(arg2);
32403
32404 wxPyEndAllowThreads(__tstate);
32405 if (PyErr_Occurred()) SWIG_fail;
32406 }
32407 {
32408 resultobj = wxPyMake_wxObject(result, 0);
32409 }
32410 return resultobj;
32411 fail:
32412 return NULL;
32413 }
32414
32415
32416 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32417 PyObject *resultobj;
32418 wxMenu *arg1 = (wxMenu *) 0 ;
32419 PyObject * obj0 = 0 ;
32420 char *kwnames[] = {
32421 (char *) "self", NULL
32422 };
32423
32424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32426 if (SWIG_arg_fail(1)) SWIG_fail;
32427 {
32428 PyThreadState* __tstate = wxPyBeginAllowThreads();
32429 (arg1)->Break();
32430
32431 wxPyEndAllowThreads(__tstate);
32432 if (PyErr_Occurred()) SWIG_fail;
32433 }
32434 Py_INCREF(Py_None); resultobj = Py_None;
32435 return resultobj;
32436 fail:
32437 return NULL;
32438 }
32439
32440
32441 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32442 PyObject *resultobj;
32443 wxMenu *arg1 = (wxMenu *) 0 ;
32444 size_t arg2 ;
32445 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32446 wxMenuItem *result;
32447 PyObject * obj0 = 0 ;
32448 PyObject * obj1 = 0 ;
32449 PyObject * obj2 = 0 ;
32450 char *kwnames[] = {
32451 (char *) "self",(char *) "pos",(char *) "item", NULL
32452 };
32453
32454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32456 if (SWIG_arg_fail(1)) SWIG_fail;
32457 {
32458 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32459 if (SWIG_arg_fail(2)) SWIG_fail;
32460 }
32461 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32462 if (SWIG_arg_fail(3)) SWIG_fail;
32463 {
32464 PyThreadState* __tstate = wxPyBeginAllowThreads();
32465 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32466
32467 wxPyEndAllowThreads(__tstate);
32468 if (PyErr_Occurred()) SWIG_fail;
32469 }
32470 {
32471 resultobj = wxPyMake_wxObject(result, 0);
32472 }
32473 return resultobj;
32474 fail:
32475 return NULL;
32476 }
32477
32478
32479 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32480 PyObject *resultobj;
32481 wxMenu *arg1 = (wxMenu *) 0 ;
32482 size_t arg2 ;
32483 int arg3 ;
32484 wxString *arg4 = 0 ;
32485 wxString const &arg5_defvalue = wxPyEmptyString ;
32486 wxString *arg5 = (wxString *) &arg5_defvalue ;
32487 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32488 wxMenuItem *result;
32489 bool temp4 = false ;
32490 bool temp5 = false ;
32491 PyObject * obj0 = 0 ;
32492 PyObject * obj1 = 0 ;
32493 PyObject * obj2 = 0 ;
32494 PyObject * obj3 = 0 ;
32495 PyObject * obj4 = 0 ;
32496 PyObject * obj5 = 0 ;
32497 char *kwnames[] = {
32498 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32499 };
32500
32501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32503 if (SWIG_arg_fail(1)) SWIG_fail;
32504 {
32505 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32506 if (SWIG_arg_fail(2)) SWIG_fail;
32507 }
32508 {
32509 arg3 = (int)(SWIG_As_int(obj2));
32510 if (SWIG_arg_fail(3)) SWIG_fail;
32511 }
32512 {
32513 arg4 = wxString_in_helper(obj3);
32514 if (arg4 == NULL) SWIG_fail;
32515 temp4 = true;
32516 }
32517 if (obj4) {
32518 {
32519 arg5 = wxString_in_helper(obj4);
32520 if (arg5 == NULL) SWIG_fail;
32521 temp5 = true;
32522 }
32523 }
32524 if (obj5) {
32525 {
32526 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32527 if (SWIG_arg_fail(6)) SWIG_fail;
32528 }
32529 }
32530 {
32531 PyThreadState* __tstate = wxPyBeginAllowThreads();
32532 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32533
32534 wxPyEndAllowThreads(__tstate);
32535 if (PyErr_Occurred()) SWIG_fail;
32536 }
32537 {
32538 resultobj = wxPyMake_wxObject(result, 0);
32539 }
32540 {
32541 if (temp4)
32542 delete arg4;
32543 }
32544 {
32545 if (temp5)
32546 delete arg5;
32547 }
32548 return resultobj;
32549 fail:
32550 {
32551 if (temp4)
32552 delete arg4;
32553 }
32554 {
32555 if (temp5)
32556 delete arg5;
32557 }
32558 return NULL;
32559 }
32560
32561
32562 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32563 PyObject *resultobj;
32564 wxMenu *arg1 = (wxMenu *) 0 ;
32565 size_t arg2 ;
32566 wxMenuItem *result;
32567 PyObject * obj0 = 0 ;
32568 PyObject * obj1 = 0 ;
32569 char *kwnames[] = {
32570 (char *) "self",(char *) "pos", NULL
32571 };
32572
32573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32575 if (SWIG_arg_fail(1)) SWIG_fail;
32576 {
32577 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32578 if (SWIG_arg_fail(2)) SWIG_fail;
32579 }
32580 {
32581 PyThreadState* __tstate = wxPyBeginAllowThreads();
32582 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
32583
32584 wxPyEndAllowThreads(__tstate);
32585 if (PyErr_Occurred()) SWIG_fail;
32586 }
32587 {
32588 resultobj = wxPyMake_wxObject(result, 0);
32589 }
32590 return resultobj;
32591 fail:
32592 return NULL;
32593 }
32594
32595
32596 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32597 PyObject *resultobj;
32598 wxMenu *arg1 = (wxMenu *) 0 ;
32599 size_t arg2 ;
32600 int arg3 ;
32601 wxString *arg4 = 0 ;
32602 wxString const &arg5_defvalue = wxPyEmptyString ;
32603 wxString *arg5 = (wxString *) &arg5_defvalue ;
32604 wxMenuItem *result;
32605 bool temp4 = false ;
32606 bool temp5 = false ;
32607 PyObject * obj0 = 0 ;
32608 PyObject * obj1 = 0 ;
32609 PyObject * obj2 = 0 ;
32610 PyObject * obj3 = 0 ;
32611 PyObject * obj4 = 0 ;
32612 char *kwnames[] = {
32613 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32614 };
32615
32616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32618 if (SWIG_arg_fail(1)) SWIG_fail;
32619 {
32620 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32621 if (SWIG_arg_fail(2)) SWIG_fail;
32622 }
32623 {
32624 arg3 = (int)(SWIG_As_int(obj2));
32625 if (SWIG_arg_fail(3)) SWIG_fail;
32626 }
32627 {
32628 arg4 = wxString_in_helper(obj3);
32629 if (arg4 == NULL) SWIG_fail;
32630 temp4 = true;
32631 }
32632 if (obj4) {
32633 {
32634 arg5 = wxString_in_helper(obj4);
32635 if (arg5 == NULL) SWIG_fail;
32636 temp5 = true;
32637 }
32638 }
32639 {
32640 PyThreadState* __tstate = wxPyBeginAllowThreads();
32641 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32642
32643 wxPyEndAllowThreads(__tstate);
32644 if (PyErr_Occurred()) SWIG_fail;
32645 }
32646 {
32647 resultobj = wxPyMake_wxObject(result, 0);
32648 }
32649 {
32650 if (temp4)
32651 delete arg4;
32652 }
32653 {
32654 if (temp5)
32655 delete arg5;
32656 }
32657 return resultobj;
32658 fail:
32659 {
32660 if (temp4)
32661 delete arg4;
32662 }
32663 {
32664 if (temp5)
32665 delete arg5;
32666 }
32667 return NULL;
32668 }
32669
32670
32671 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32672 PyObject *resultobj;
32673 wxMenu *arg1 = (wxMenu *) 0 ;
32674 size_t arg2 ;
32675 int arg3 ;
32676 wxString *arg4 = 0 ;
32677 wxString const &arg5_defvalue = wxPyEmptyString ;
32678 wxString *arg5 = (wxString *) &arg5_defvalue ;
32679 wxMenuItem *result;
32680 bool temp4 = false ;
32681 bool temp5 = false ;
32682 PyObject * obj0 = 0 ;
32683 PyObject * obj1 = 0 ;
32684 PyObject * obj2 = 0 ;
32685 PyObject * obj3 = 0 ;
32686 PyObject * obj4 = 0 ;
32687 char *kwnames[] = {
32688 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32689 };
32690
32691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32693 if (SWIG_arg_fail(1)) SWIG_fail;
32694 {
32695 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32696 if (SWIG_arg_fail(2)) SWIG_fail;
32697 }
32698 {
32699 arg3 = (int)(SWIG_As_int(obj2));
32700 if (SWIG_arg_fail(3)) SWIG_fail;
32701 }
32702 {
32703 arg4 = wxString_in_helper(obj3);
32704 if (arg4 == NULL) SWIG_fail;
32705 temp4 = true;
32706 }
32707 if (obj4) {
32708 {
32709 arg5 = wxString_in_helper(obj4);
32710 if (arg5 == NULL) SWIG_fail;
32711 temp5 = true;
32712 }
32713 }
32714 {
32715 PyThreadState* __tstate = wxPyBeginAllowThreads();
32716 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32717
32718 wxPyEndAllowThreads(__tstate);
32719 if (PyErr_Occurred()) SWIG_fail;
32720 }
32721 {
32722 resultobj = wxPyMake_wxObject(result, 0);
32723 }
32724 {
32725 if (temp4)
32726 delete arg4;
32727 }
32728 {
32729 if (temp5)
32730 delete arg5;
32731 }
32732 return resultobj;
32733 fail:
32734 {
32735 if (temp4)
32736 delete arg4;
32737 }
32738 {
32739 if (temp5)
32740 delete arg5;
32741 }
32742 return NULL;
32743 }
32744
32745
32746 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32747 PyObject *resultobj;
32748 wxMenu *arg1 = (wxMenu *) 0 ;
32749 size_t arg2 ;
32750 int arg3 ;
32751 wxString *arg4 = 0 ;
32752 wxMenu *arg5 = (wxMenu *) 0 ;
32753 wxString const &arg6_defvalue = wxPyEmptyString ;
32754 wxString *arg6 = (wxString *) &arg6_defvalue ;
32755 wxMenuItem *result;
32756 bool temp4 = false ;
32757 bool temp6 = false ;
32758 PyObject * obj0 = 0 ;
32759 PyObject * obj1 = 0 ;
32760 PyObject * obj2 = 0 ;
32761 PyObject * obj3 = 0 ;
32762 PyObject * obj4 = 0 ;
32763 PyObject * obj5 = 0 ;
32764 char *kwnames[] = {
32765 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32766 };
32767
32768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32770 if (SWIG_arg_fail(1)) SWIG_fail;
32771 {
32772 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32773 if (SWIG_arg_fail(2)) SWIG_fail;
32774 }
32775 {
32776 arg3 = (int)(SWIG_As_int(obj2));
32777 if (SWIG_arg_fail(3)) SWIG_fail;
32778 }
32779 {
32780 arg4 = wxString_in_helper(obj3);
32781 if (arg4 == NULL) SWIG_fail;
32782 temp4 = true;
32783 }
32784 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32785 if (SWIG_arg_fail(5)) SWIG_fail;
32786 if (obj5) {
32787 {
32788 arg6 = wxString_in_helper(obj5);
32789 if (arg6 == NULL) SWIG_fail;
32790 temp6 = true;
32791 }
32792 }
32793 {
32794 PyThreadState* __tstate = wxPyBeginAllowThreads();
32795 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
32796
32797 wxPyEndAllowThreads(__tstate);
32798 if (PyErr_Occurred()) SWIG_fail;
32799 }
32800 {
32801 resultobj = wxPyMake_wxObject(result, 0);
32802 }
32803 {
32804 if (temp4)
32805 delete arg4;
32806 }
32807 {
32808 if (temp6)
32809 delete arg6;
32810 }
32811 return resultobj;
32812 fail:
32813 {
32814 if (temp4)
32815 delete arg4;
32816 }
32817 {
32818 if (temp6)
32819 delete arg6;
32820 }
32821 return NULL;
32822 }
32823
32824
32825 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
32826 PyObject *resultobj;
32827 wxMenu *arg1 = (wxMenu *) 0 ;
32828 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32829 wxMenuItem *result;
32830 PyObject * obj0 = 0 ;
32831 PyObject * obj1 = 0 ;
32832 char *kwnames[] = {
32833 (char *) "self",(char *) "item", NULL
32834 };
32835
32836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
32837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32838 if (SWIG_arg_fail(1)) SWIG_fail;
32839 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32840 if (SWIG_arg_fail(2)) SWIG_fail;
32841 {
32842 PyThreadState* __tstate = wxPyBeginAllowThreads();
32843 result = (wxMenuItem *)(arg1)->Prepend(arg2);
32844
32845 wxPyEndAllowThreads(__tstate);
32846 if (PyErr_Occurred()) SWIG_fail;
32847 }
32848 {
32849 resultobj = wxPyMake_wxObject(result, 0);
32850 }
32851 return resultobj;
32852 fail:
32853 return NULL;
32854 }
32855
32856
32857 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
32858 PyObject *resultobj;
32859 wxMenu *arg1 = (wxMenu *) 0 ;
32860 int arg2 ;
32861 wxString *arg3 = 0 ;
32862 wxString const &arg4_defvalue = wxPyEmptyString ;
32863 wxString *arg4 = (wxString *) &arg4_defvalue ;
32864 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32865 wxMenuItem *result;
32866 bool temp3 = false ;
32867 bool temp4 = false ;
32868 PyObject * obj0 = 0 ;
32869 PyObject * obj1 = 0 ;
32870 PyObject * obj2 = 0 ;
32871 PyObject * obj3 = 0 ;
32872 PyObject * obj4 = 0 ;
32873 char *kwnames[] = {
32874 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32875 };
32876
32877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32879 if (SWIG_arg_fail(1)) SWIG_fail;
32880 {
32881 arg2 = (int)(SWIG_As_int(obj1));
32882 if (SWIG_arg_fail(2)) SWIG_fail;
32883 }
32884 {
32885 arg3 = wxString_in_helper(obj2);
32886 if (arg3 == NULL) SWIG_fail;
32887 temp3 = true;
32888 }
32889 if (obj3) {
32890 {
32891 arg4 = wxString_in_helper(obj3);
32892 if (arg4 == NULL) SWIG_fail;
32893 temp4 = true;
32894 }
32895 }
32896 if (obj4) {
32897 {
32898 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32899 if (SWIG_arg_fail(5)) SWIG_fail;
32900 }
32901 }
32902 {
32903 PyThreadState* __tstate = wxPyBeginAllowThreads();
32904 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32905
32906 wxPyEndAllowThreads(__tstate);
32907 if (PyErr_Occurred()) SWIG_fail;
32908 }
32909 {
32910 resultobj = wxPyMake_wxObject(result, 0);
32911 }
32912 {
32913 if (temp3)
32914 delete arg3;
32915 }
32916 {
32917 if (temp4)
32918 delete arg4;
32919 }
32920 return resultobj;
32921 fail:
32922 {
32923 if (temp3)
32924 delete arg3;
32925 }
32926 {
32927 if (temp4)
32928 delete arg4;
32929 }
32930 return NULL;
32931 }
32932
32933
32934 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32935 PyObject *resultobj;
32936 wxMenu *arg1 = (wxMenu *) 0 ;
32937 wxMenuItem *result;
32938 PyObject * obj0 = 0 ;
32939 char *kwnames[] = {
32940 (char *) "self", NULL
32941 };
32942
32943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
32944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32945 if (SWIG_arg_fail(1)) SWIG_fail;
32946 {
32947 PyThreadState* __tstate = wxPyBeginAllowThreads();
32948 result = (wxMenuItem *)(arg1)->PrependSeparator();
32949
32950 wxPyEndAllowThreads(__tstate);
32951 if (PyErr_Occurred()) SWIG_fail;
32952 }
32953 {
32954 resultobj = wxPyMake_wxObject(result, 0);
32955 }
32956 return resultobj;
32957 fail:
32958 return NULL;
32959 }
32960
32961
32962 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32963 PyObject *resultobj;
32964 wxMenu *arg1 = (wxMenu *) 0 ;
32965 int arg2 ;
32966 wxString *arg3 = 0 ;
32967 wxString const &arg4_defvalue = wxPyEmptyString ;
32968 wxString *arg4 = (wxString *) &arg4_defvalue ;
32969 wxMenuItem *result;
32970 bool temp3 = false ;
32971 bool temp4 = false ;
32972 PyObject * obj0 = 0 ;
32973 PyObject * obj1 = 0 ;
32974 PyObject * obj2 = 0 ;
32975 PyObject * obj3 = 0 ;
32976 char *kwnames[] = {
32977 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32978 };
32979
32980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32982 if (SWIG_arg_fail(1)) SWIG_fail;
32983 {
32984 arg2 = (int)(SWIG_As_int(obj1));
32985 if (SWIG_arg_fail(2)) SWIG_fail;
32986 }
32987 {
32988 arg3 = wxString_in_helper(obj2);
32989 if (arg3 == NULL) SWIG_fail;
32990 temp3 = true;
32991 }
32992 if (obj3) {
32993 {
32994 arg4 = wxString_in_helper(obj3);
32995 if (arg4 == NULL) SWIG_fail;
32996 temp4 = true;
32997 }
32998 }
32999 {
33000 PyThreadState* __tstate = wxPyBeginAllowThreads();
33001 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33002
33003 wxPyEndAllowThreads(__tstate);
33004 if (PyErr_Occurred()) SWIG_fail;
33005 }
33006 {
33007 resultobj = wxPyMake_wxObject(result, 0);
33008 }
33009 {
33010 if (temp3)
33011 delete arg3;
33012 }
33013 {
33014 if (temp4)
33015 delete arg4;
33016 }
33017 return resultobj;
33018 fail:
33019 {
33020 if (temp3)
33021 delete arg3;
33022 }
33023 {
33024 if (temp4)
33025 delete arg4;
33026 }
33027 return NULL;
33028 }
33029
33030
33031 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33032 PyObject *resultobj;
33033 wxMenu *arg1 = (wxMenu *) 0 ;
33034 int arg2 ;
33035 wxString *arg3 = 0 ;
33036 wxString const &arg4_defvalue = wxPyEmptyString ;
33037 wxString *arg4 = (wxString *) &arg4_defvalue ;
33038 wxMenuItem *result;
33039 bool temp3 = false ;
33040 bool temp4 = false ;
33041 PyObject * obj0 = 0 ;
33042 PyObject * obj1 = 0 ;
33043 PyObject * obj2 = 0 ;
33044 PyObject * obj3 = 0 ;
33045 char *kwnames[] = {
33046 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33047 };
33048
33049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33051 if (SWIG_arg_fail(1)) SWIG_fail;
33052 {
33053 arg2 = (int)(SWIG_As_int(obj1));
33054 if (SWIG_arg_fail(2)) SWIG_fail;
33055 }
33056 {
33057 arg3 = wxString_in_helper(obj2);
33058 if (arg3 == NULL) SWIG_fail;
33059 temp3 = true;
33060 }
33061 if (obj3) {
33062 {
33063 arg4 = wxString_in_helper(obj3);
33064 if (arg4 == NULL) SWIG_fail;
33065 temp4 = true;
33066 }
33067 }
33068 {
33069 PyThreadState* __tstate = wxPyBeginAllowThreads();
33070 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33071
33072 wxPyEndAllowThreads(__tstate);
33073 if (PyErr_Occurred()) SWIG_fail;
33074 }
33075 {
33076 resultobj = wxPyMake_wxObject(result, 0);
33077 }
33078 {
33079 if (temp3)
33080 delete arg3;
33081 }
33082 {
33083 if (temp4)
33084 delete arg4;
33085 }
33086 return resultobj;
33087 fail:
33088 {
33089 if (temp3)
33090 delete arg3;
33091 }
33092 {
33093 if (temp4)
33094 delete arg4;
33095 }
33096 return NULL;
33097 }
33098
33099
33100 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33101 PyObject *resultobj;
33102 wxMenu *arg1 = (wxMenu *) 0 ;
33103 int arg2 ;
33104 wxString *arg3 = 0 ;
33105 wxMenu *arg4 = (wxMenu *) 0 ;
33106 wxString const &arg5_defvalue = wxPyEmptyString ;
33107 wxString *arg5 = (wxString *) &arg5_defvalue ;
33108 wxMenuItem *result;
33109 bool temp3 = false ;
33110 bool temp5 = false ;
33111 PyObject * obj0 = 0 ;
33112 PyObject * obj1 = 0 ;
33113 PyObject * obj2 = 0 ;
33114 PyObject * obj3 = 0 ;
33115 PyObject * obj4 = 0 ;
33116 char *kwnames[] = {
33117 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33118 };
33119
33120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33122 if (SWIG_arg_fail(1)) SWIG_fail;
33123 {
33124 arg2 = (int)(SWIG_As_int(obj1));
33125 if (SWIG_arg_fail(2)) SWIG_fail;
33126 }
33127 {
33128 arg3 = wxString_in_helper(obj2);
33129 if (arg3 == NULL) SWIG_fail;
33130 temp3 = true;
33131 }
33132 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33133 if (SWIG_arg_fail(4)) SWIG_fail;
33134 if (obj4) {
33135 {
33136 arg5 = wxString_in_helper(obj4);
33137 if (arg5 == NULL) SWIG_fail;
33138 temp5 = true;
33139 }
33140 }
33141 {
33142 PyThreadState* __tstate = wxPyBeginAllowThreads();
33143 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33144
33145 wxPyEndAllowThreads(__tstate);
33146 if (PyErr_Occurred()) SWIG_fail;
33147 }
33148 {
33149 resultobj = wxPyMake_wxObject(result, 0);
33150 }
33151 {
33152 if (temp3)
33153 delete arg3;
33154 }
33155 {
33156 if (temp5)
33157 delete arg5;
33158 }
33159 return resultobj;
33160 fail:
33161 {
33162 if (temp3)
33163 delete arg3;
33164 }
33165 {
33166 if (temp5)
33167 delete arg5;
33168 }
33169 return NULL;
33170 }
33171
33172
33173 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33174 PyObject *resultobj;
33175 wxMenu *arg1 = (wxMenu *) 0 ;
33176 int arg2 ;
33177 wxMenuItem *result;
33178 PyObject * obj0 = 0 ;
33179 PyObject * obj1 = 0 ;
33180 char *kwnames[] = {
33181 (char *) "self",(char *) "id", NULL
33182 };
33183
33184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33186 if (SWIG_arg_fail(1)) SWIG_fail;
33187 {
33188 arg2 = (int)(SWIG_As_int(obj1));
33189 if (SWIG_arg_fail(2)) SWIG_fail;
33190 }
33191 {
33192 PyThreadState* __tstate = wxPyBeginAllowThreads();
33193 result = (wxMenuItem *)(arg1)->Remove(arg2);
33194
33195 wxPyEndAllowThreads(__tstate);
33196 if (PyErr_Occurred()) SWIG_fail;
33197 }
33198 {
33199 resultobj = wxPyMake_wxObject(result, 0);
33200 }
33201 return resultobj;
33202 fail:
33203 return NULL;
33204 }
33205
33206
33207 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33208 PyObject *resultobj;
33209 wxMenu *arg1 = (wxMenu *) 0 ;
33210 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33211 wxMenuItem *result;
33212 PyObject * obj0 = 0 ;
33213 PyObject * obj1 = 0 ;
33214 char *kwnames[] = {
33215 (char *) "self",(char *) "item", NULL
33216 };
33217
33218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33220 if (SWIG_arg_fail(1)) SWIG_fail;
33221 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33222 if (SWIG_arg_fail(2)) SWIG_fail;
33223 {
33224 PyThreadState* __tstate = wxPyBeginAllowThreads();
33225 result = (wxMenuItem *)(arg1)->Remove(arg2);
33226
33227 wxPyEndAllowThreads(__tstate);
33228 if (PyErr_Occurred()) SWIG_fail;
33229 }
33230 {
33231 resultobj = wxPyMake_wxObject(result, 0);
33232 }
33233 return resultobj;
33234 fail:
33235 return NULL;
33236 }
33237
33238
33239 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33240 PyObject *resultobj;
33241 wxMenu *arg1 = (wxMenu *) 0 ;
33242 int arg2 ;
33243 bool result;
33244 PyObject * obj0 = 0 ;
33245 PyObject * obj1 = 0 ;
33246 char *kwnames[] = {
33247 (char *) "self",(char *) "id", NULL
33248 };
33249
33250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33252 if (SWIG_arg_fail(1)) SWIG_fail;
33253 {
33254 arg2 = (int)(SWIG_As_int(obj1));
33255 if (SWIG_arg_fail(2)) SWIG_fail;
33256 }
33257 {
33258 PyThreadState* __tstate = wxPyBeginAllowThreads();
33259 result = (bool)(arg1)->Delete(arg2);
33260
33261 wxPyEndAllowThreads(__tstate);
33262 if (PyErr_Occurred()) SWIG_fail;
33263 }
33264 {
33265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33266 }
33267 return resultobj;
33268 fail:
33269 return NULL;
33270 }
33271
33272
33273 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33274 PyObject *resultobj;
33275 wxMenu *arg1 = (wxMenu *) 0 ;
33276 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33277 bool result;
33278 PyObject * obj0 = 0 ;
33279 PyObject * obj1 = 0 ;
33280 char *kwnames[] = {
33281 (char *) "self",(char *) "item", NULL
33282 };
33283
33284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33286 if (SWIG_arg_fail(1)) SWIG_fail;
33287 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33288 if (SWIG_arg_fail(2)) SWIG_fail;
33289 {
33290 PyThreadState* __tstate = wxPyBeginAllowThreads();
33291 result = (bool)(arg1)->Delete(arg2);
33292
33293 wxPyEndAllowThreads(__tstate);
33294 if (PyErr_Occurred()) SWIG_fail;
33295 }
33296 {
33297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33298 }
33299 return resultobj;
33300 fail:
33301 return NULL;
33302 }
33303
33304
33305 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33306 PyObject *resultobj;
33307 wxMenu *arg1 = (wxMenu *) 0 ;
33308 PyObject * obj0 = 0 ;
33309 char *kwnames[] = {
33310 (char *) "self", NULL
33311 };
33312
33313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33315 if (SWIG_arg_fail(1)) SWIG_fail;
33316 {
33317 PyThreadState* __tstate = wxPyBeginAllowThreads();
33318 wxMenu_Destroy(arg1);
33319
33320 wxPyEndAllowThreads(__tstate);
33321 if (PyErr_Occurred()) SWIG_fail;
33322 }
33323 Py_INCREF(Py_None); resultobj = Py_None;
33324 return resultobj;
33325 fail:
33326 return NULL;
33327 }
33328
33329
33330 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33331 PyObject *resultobj;
33332 wxMenu *arg1 = (wxMenu *) 0 ;
33333 int arg2 ;
33334 bool result;
33335 PyObject * obj0 = 0 ;
33336 PyObject * obj1 = 0 ;
33337 char *kwnames[] = {
33338 (char *) "self",(char *) "id", NULL
33339 };
33340
33341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33343 if (SWIG_arg_fail(1)) SWIG_fail;
33344 {
33345 arg2 = (int)(SWIG_As_int(obj1));
33346 if (SWIG_arg_fail(2)) SWIG_fail;
33347 }
33348 {
33349 PyThreadState* __tstate = wxPyBeginAllowThreads();
33350 result = (bool)(arg1)->Destroy(arg2);
33351
33352 wxPyEndAllowThreads(__tstate);
33353 if (PyErr_Occurred()) SWIG_fail;
33354 }
33355 {
33356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33357 }
33358 return resultobj;
33359 fail:
33360 return NULL;
33361 }
33362
33363
33364 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33365 PyObject *resultobj;
33366 wxMenu *arg1 = (wxMenu *) 0 ;
33367 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33368 bool result;
33369 PyObject * obj0 = 0 ;
33370 PyObject * obj1 = 0 ;
33371 char *kwnames[] = {
33372 (char *) "self",(char *) "item", NULL
33373 };
33374
33375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33377 if (SWIG_arg_fail(1)) SWIG_fail;
33378 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33379 if (SWIG_arg_fail(2)) SWIG_fail;
33380 {
33381 PyThreadState* __tstate = wxPyBeginAllowThreads();
33382 result = (bool)(arg1)->Destroy(arg2);
33383
33384 wxPyEndAllowThreads(__tstate);
33385 if (PyErr_Occurred()) SWIG_fail;
33386 }
33387 {
33388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33389 }
33390 return resultobj;
33391 fail:
33392 return NULL;
33393 }
33394
33395
33396 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33397 PyObject *resultobj;
33398 wxMenu *arg1 = (wxMenu *) 0 ;
33399 size_t result;
33400 PyObject * obj0 = 0 ;
33401 char *kwnames[] = {
33402 (char *) "self", NULL
33403 };
33404
33405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33407 if (SWIG_arg_fail(1)) SWIG_fail;
33408 {
33409 PyThreadState* __tstate = wxPyBeginAllowThreads();
33410 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33411
33412 wxPyEndAllowThreads(__tstate);
33413 if (PyErr_Occurred()) SWIG_fail;
33414 }
33415 {
33416 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33417 }
33418 return resultobj;
33419 fail:
33420 return NULL;
33421 }
33422
33423
33424 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33425 PyObject *resultobj;
33426 wxMenu *arg1 = (wxMenu *) 0 ;
33427 PyObject *result;
33428 PyObject * obj0 = 0 ;
33429 char *kwnames[] = {
33430 (char *) "self", NULL
33431 };
33432
33433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33435 if (SWIG_arg_fail(1)) SWIG_fail;
33436 {
33437 PyThreadState* __tstate = wxPyBeginAllowThreads();
33438 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33439
33440 wxPyEndAllowThreads(__tstate);
33441 if (PyErr_Occurred()) SWIG_fail;
33442 }
33443 resultobj = result;
33444 return resultobj;
33445 fail:
33446 return NULL;
33447 }
33448
33449
33450 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33451 PyObject *resultobj;
33452 wxMenu *arg1 = (wxMenu *) 0 ;
33453 wxString *arg2 = 0 ;
33454 int result;
33455 bool temp2 = false ;
33456 PyObject * obj0 = 0 ;
33457 PyObject * obj1 = 0 ;
33458 char *kwnames[] = {
33459 (char *) "self",(char *) "item", NULL
33460 };
33461
33462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33464 if (SWIG_arg_fail(1)) SWIG_fail;
33465 {
33466 arg2 = wxString_in_helper(obj1);
33467 if (arg2 == NULL) SWIG_fail;
33468 temp2 = true;
33469 }
33470 {
33471 PyThreadState* __tstate = wxPyBeginAllowThreads();
33472 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33473
33474 wxPyEndAllowThreads(__tstate);
33475 if (PyErr_Occurred()) SWIG_fail;
33476 }
33477 {
33478 resultobj = SWIG_From_int((int)(result));
33479 }
33480 {
33481 if (temp2)
33482 delete arg2;
33483 }
33484 return resultobj;
33485 fail:
33486 {
33487 if (temp2)
33488 delete arg2;
33489 }
33490 return NULL;
33491 }
33492
33493
33494 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33495 PyObject *resultobj;
33496 wxMenu *arg1 = (wxMenu *) 0 ;
33497 int arg2 ;
33498 wxMenuItem *result;
33499 PyObject * obj0 = 0 ;
33500 PyObject * obj1 = 0 ;
33501 char *kwnames[] = {
33502 (char *) "self",(char *) "id", NULL
33503 };
33504
33505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
33506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33507 if (SWIG_arg_fail(1)) SWIG_fail;
33508 {
33509 arg2 = (int)(SWIG_As_int(obj1));
33510 if (SWIG_arg_fail(2)) SWIG_fail;
33511 }
33512 {
33513 PyThreadState* __tstate = wxPyBeginAllowThreads();
33514 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33515
33516 wxPyEndAllowThreads(__tstate);
33517 if (PyErr_Occurred()) SWIG_fail;
33518 }
33519 {
33520 resultobj = wxPyMake_wxObject(result, 0);
33521 }
33522 return resultobj;
33523 fail:
33524 return NULL;
33525 }
33526
33527
33528 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33529 PyObject *resultobj;
33530 wxMenu *arg1 = (wxMenu *) 0 ;
33531 size_t arg2 ;
33532 wxMenuItem *result;
33533 PyObject * obj0 = 0 ;
33534 PyObject * obj1 = 0 ;
33535 char *kwnames[] = {
33536 (char *) "self",(char *) "position", NULL
33537 };
33538
33539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33541 if (SWIG_arg_fail(1)) SWIG_fail;
33542 {
33543 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33544 if (SWIG_arg_fail(2)) SWIG_fail;
33545 }
33546 {
33547 PyThreadState* __tstate = wxPyBeginAllowThreads();
33548 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33549
33550 wxPyEndAllowThreads(__tstate);
33551 if (PyErr_Occurred()) SWIG_fail;
33552 }
33553 {
33554 resultobj = wxPyMake_wxObject(result, 0);
33555 }
33556 return resultobj;
33557 fail:
33558 return NULL;
33559 }
33560
33561
33562 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33563 PyObject *resultobj;
33564 wxMenu *arg1 = (wxMenu *) 0 ;
33565 int arg2 ;
33566 bool arg3 ;
33567 PyObject * obj0 = 0 ;
33568 PyObject * obj1 = 0 ;
33569 PyObject * obj2 = 0 ;
33570 char *kwnames[] = {
33571 (char *) "self",(char *) "id",(char *) "enable", NULL
33572 };
33573
33574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33576 if (SWIG_arg_fail(1)) SWIG_fail;
33577 {
33578 arg2 = (int)(SWIG_As_int(obj1));
33579 if (SWIG_arg_fail(2)) SWIG_fail;
33580 }
33581 {
33582 arg3 = (bool)(SWIG_As_bool(obj2));
33583 if (SWIG_arg_fail(3)) SWIG_fail;
33584 }
33585 {
33586 PyThreadState* __tstate = wxPyBeginAllowThreads();
33587 (arg1)->Enable(arg2,arg3);
33588
33589 wxPyEndAllowThreads(__tstate);
33590 if (PyErr_Occurred()) SWIG_fail;
33591 }
33592 Py_INCREF(Py_None); resultobj = Py_None;
33593 return resultobj;
33594 fail:
33595 return NULL;
33596 }
33597
33598
33599 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
33600 PyObject *resultobj;
33601 wxMenu *arg1 = (wxMenu *) 0 ;
33602 int arg2 ;
33603 bool result;
33604 PyObject * obj0 = 0 ;
33605 PyObject * obj1 = 0 ;
33606 char *kwnames[] = {
33607 (char *) "self",(char *) "id", NULL
33608 };
33609
33610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
33611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33612 if (SWIG_arg_fail(1)) SWIG_fail;
33613 {
33614 arg2 = (int)(SWIG_As_int(obj1));
33615 if (SWIG_arg_fail(2)) SWIG_fail;
33616 }
33617 {
33618 PyThreadState* __tstate = wxPyBeginAllowThreads();
33619 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
33620
33621 wxPyEndAllowThreads(__tstate);
33622 if (PyErr_Occurred()) SWIG_fail;
33623 }
33624 {
33625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33626 }
33627 return resultobj;
33628 fail:
33629 return NULL;
33630 }
33631
33632
33633 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
33634 PyObject *resultobj;
33635 wxMenu *arg1 = (wxMenu *) 0 ;
33636 int arg2 ;
33637 bool arg3 ;
33638 PyObject * obj0 = 0 ;
33639 PyObject * obj1 = 0 ;
33640 PyObject * obj2 = 0 ;
33641 char *kwnames[] = {
33642 (char *) "self",(char *) "id",(char *) "check", NULL
33643 };
33644
33645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
33646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33647 if (SWIG_arg_fail(1)) SWIG_fail;
33648 {
33649 arg2 = (int)(SWIG_As_int(obj1));
33650 if (SWIG_arg_fail(2)) SWIG_fail;
33651 }
33652 {
33653 arg3 = (bool)(SWIG_As_bool(obj2));
33654 if (SWIG_arg_fail(3)) SWIG_fail;
33655 }
33656 {
33657 PyThreadState* __tstate = wxPyBeginAllowThreads();
33658 (arg1)->Check(arg2,arg3);
33659
33660 wxPyEndAllowThreads(__tstate);
33661 if (PyErr_Occurred()) SWIG_fail;
33662 }
33663 Py_INCREF(Py_None); resultobj = Py_None;
33664 return resultobj;
33665 fail:
33666 return NULL;
33667 }
33668
33669
33670 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
33671 PyObject *resultobj;
33672 wxMenu *arg1 = (wxMenu *) 0 ;
33673 int arg2 ;
33674 bool result;
33675 PyObject * obj0 = 0 ;
33676 PyObject * obj1 = 0 ;
33677 char *kwnames[] = {
33678 (char *) "self",(char *) "id", NULL
33679 };
33680
33681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
33682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33683 if (SWIG_arg_fail(1)) SWIG_fail;
33684 {
33685 arg2 = (int)(SWIG_As_int(obj1));
33686 if (SWIG_arg_fail(2)) SWIG_fail;
33687 }
33688 {
33689 PyThreadState* __tstate = wxPyBeginAllowThreads();
33690 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
33691
33692 wxPyEndAllowThreads(__tstate);
33693 if (PyErr_Occurred()) SWIG_fail;
33694 }
33695 {
33696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33697 }
33698 return resultobj;
33699 fail:
33700 return NULL;
33701 }
33702
33703
33704 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33705 PyObject *resultobj;
33706 wxMenu *arg1 = (wxMenu *) 0 ;
33707 int arg2 ;
33708 wxString *arg3 = 0 ;
33709 bool temp3 = false ;
33710 PyObject * obj0 = 0 ;
33711 PyObject * obj1 = 0 ;
33712 PyObject * obj2 = 0 ;
33713 char *kwnames[] = {
33714 (char *) "self",(char *) "id",(char *) "label", NULL
33715 };
33716
33717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
33718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33719 if (SWIG_arg_fail(1)) SWIG_fail;
33720 {
33721 arg2 = (int)(SWIG_As_int(obj1));
33722 if (SWIG_arg_fail(2)) SWIG_fail;
33723 }
33724 {
33725 arg3 = wxString_in_helper(obj2);
33726 if (arg3 == NULL) SWIG_fail;
33727 temp3 = true;
33728 }
33729 {
33730 PyThreadState* __tstate = wxPyBeginAllowThreads();
33731 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
33732
33733 wxPyEndAllowThreads(__tstate);
33734 if (PyErr_Occurred()) SWIG_fail;
33735 }
33736 Py_INCREF(Py_None); resultobj = Py_None;
33737 {
33738 if (temp3)
33739 delete arg3;
33740 }
33741 return resultobj;
33742 fail:
33743 {
33744 if (temp3)
33745 delete arg3;
33746 }
33747 return NULL;
33748 }
33749
33750
33751 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33752 PyObject *resultobj;
33753 wxMenu *arg1 = (wxMenu *) 0 ;
33754 int arg2 ;
33755 wxString result;
33756 PyObject * obj0 = 0 ;
33757 PyObject * obj1 = 0 ;
33758 char *kwnames[] = {
33759 (char *) "self",(char *) "id", NULL
33760 };
33761
33762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
33763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33764 if (SWIG_arg_fail(1)) SWIG_fail;
33765 {
33766 arg2 = (int)(SWIG_As_int(obj1));
33767 if (SWIG_arg_fail(2)) SWIG_fail;
33768 }
33769 {
33770 PyThreadState* __tstate = wxPyBeginAllowThreads();
33771 result = ((wxMenu const *)arg1)->GetLabel(arg2);
33772
33773 wxPyEndAllowThreads(__tstate);
33774 if (PyErr_Occurred()) SWIG_fail;
33775 }
33776 {
33777 #if wxUSE_UNICODE
33778 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33779 #else
33780 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33781 #endif
33782 }
33783 return resultobj;
33784 fail:
33785 return NULL;
33786 }
33787
33788
33789 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33790 PyObject *resultobj;
33791 wxMenu *arg1 = (wxMenu *) 0 ;
33792 int arg2 ;
33793 wxString *arg3 = 0 ;
33794 bool temp3 = false ;
33795 PyObject * obj0 = 0 ;
33796 PyObject * obj1 = 0 ;
33797 PyObject * obj2 = 0 ;
33798 char *kwnames[] = {
33799 (char *) "self",(char *) "id",(char *) "helpString", NULL
33800 };
33801
33802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
33803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33804 if (SWIG_arg_fail(1)) SWIG_fail;
33805 {
33806 arg2 = (int)(SWIG_As_int(obj1));
33807 if (SWIG_arg_fail(2)) SWIG_fail;
33808 }
33809 {
33810 arg3 = wxString_in_helper(obj2);
33811 if (arg3 == NULL) SWIG_fail;
33812 temp3 = true;
33813 }
33814 {
33815 PyThreadState* __tstate = wxPyBeginAllowThreads();
33816 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
33817
33818 wxPyEndAllowThreads(__tstate);
33819 if (PyErr_Occurred()) SWIG_fail;
33820 }
33821 Py_INCREF(Py_None); resultobj = Py_None;
33822 {
33823 if (temp3)
33824 delete arg3;
33825 }
33826 return resultobj;
33827 fail:
33828 {
33829 if (temp3)
33830 delete arg3;
33831 }
33832 return NULL;
33833 }
33834
33835
33836 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33837 PyObject *resultobj;
33838 wxMenu *arg1 = (wxMenu *) 0 ;
33839 int arg2 ;
33840 wxString result;
33841 PyObject * obj0 = 0 ;
33842 PyObject * obj1 = 0 ;
33843 char *kwnames[] = {
33844 (char *) "self",(char *) "id", NULL
33845 };
33846
33847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
33848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33849 if (SWIG_arg_fail(1)) SWIG_fail;
33850 {
33851 arg2 = (int)(SWIG_As_int(obj1));
33852 if (SWIG_arg_fail(2)) SWIG_fail;
33853 }
33854 {
33855 PyThreadState* __tstate = wxPyBeginAllowThreads();
33856 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
33857
33858 wxPyEndAllowThreads(__tstate);
33859 if (PyErr_Occurred()) SWIG_fail;
33860 }
33861 {
33862 #if wxUSE_UNICODE
33863 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33864 #else
33865 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33866 #endif
33867 }
33868 return resultobj;
33869 fail:
33870 return NULL;
33871 }
33872
33873
33874 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33875 PyObject *resultobj;
33876 wxMenu *arg1 = (wxMenu *) 0 ;
33877 wxString *arg2 = 0 ;
33878 bool temp2 = false ;
33879 PyObject * obj0 = 0 ;
33880 PyObject * obj1 = 0 ;
33881 char *kwnames[] = {
33882 (char *) "self",(char *) "title", NULL
33883 };
33884
33885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
33886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33887 if (SWIG_arg_fail(1)) SWIG_fail;
33888 {
33889 arg2 = wxString_in_helper(obj1);
33890 if (arg2 == NULL) SWIG_fail;
33891 temp2 = true;
33892 }
33893 {
33894 PyThreadState* __tstate = wxPyBeginAllowThreads();
33895 (arg1)->SetTitle((wxString const &)*arg2);
33896
33897 wxPyEndAllowThreads(__tstate);
33898 if (PyErr_Occurred()) SWIG_fail;
33899 }
33900 Py_INCREF(Py_None); resultobj = Py_None;
33901 {
33902 if (temp2)
33903 delete arg2;
33904 }
33905 return resultobj;
33906 fail:
33907 {
33908 if (temp2)
33909 delete arg2;
33910 }
33911 return NULL;
33912 }
33913
33914
33915 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33916 PyObject *resultobj;
33917 wxMenu *arg1 = (wxMenu *) 0 ;
33918 wxString result;
33919 PyObject * obj0 = 0 ;
33920 char *kwnames[] = {
33921 (char *) "self", NULL
33922 };
33923
33924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
33925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33926 if (SWIG_arg_fail(1)) SWIG_fail;
33927 {
33928 PyThreadState* __tstate = wxPyBeginAllowThreads();
33929 result = ((wxMenu const *)arg1)->GetTitle();
33930
33931 wxPyEndAllowThreads(__tstate);
33932 if (PyErr_Occurred()) SWIG_fail;
33933 }
33934 {
33935 #if wxUSE_UNICODE
33936 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33937 #else
33938 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33939 #endif
33940 }
33941 return resultobj;
33942 fail:
33943 return NULL;
33944 }
33945
33946
33947 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33948 PyObject *resultobj;
33949 wxMenu *arg1 = (wxMenu *) 0 ;
33950 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33951 PyObject * obj0 = 0 ;
33952 PyObject * obj1 = 0 ;
33953 char *kwnames[] = {
33954 (char *) "self",(char *) "handler", NULL
33955 };
33956
33957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
33958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33959 if (SWIG_arg_fail(1)) SWIG_fail;
33960 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
33961 if (SWIG_arg_fail(2)) SWIG_fail;
33962 {
33963 PyThreadState* __tstate = wxPyBeginAllowThreads();
33964 (arg1)->SetEventHandler(arg2);
33965
33966 wxPyEndAllowThreads(__tstate);
33967 if (PyErr_Occurred()) SWIG_fail;
33968 }
33969 Py_INCREF(Py_None); resultobj = Py_None;
33970 return resultobj;
33971 fail:
33972 return NULL;
33973 }
33974
33975
33976 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33977 PyObject *resultobj;
33978 wxMenu *arg1 = (wxMenu *) 0 ;
33979 wxEvtHandler *result;
33980 PyObject * obj0 = 0 ;
33981 char *kwnames[] = {
33982 (char *) "self", NULL
33983 };
33984
33985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
33986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33987 if (SWIG_arg_fail(1)) SWIG_fail;
33988 {
33989 PyThreadState* __tstate = wxPyBeginAllowThreads();
33990 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
33991
33992 wxPyEndAllowThreads(__tstate);
33993 if (PyErr_Occurred()) SWIG_fail;
33994 }
33995 {
33996 resultobj = wxPyMake_wxObject(result, 0);
33997 }
33998 return resultobj;
33999 fail:
34000 return NULL;
34001 }
34002
34003
34004 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34005 PyObject *resultobj;
34006 wxMenu *arg1 = (wxMenu *) 0 ;
34007 wxWindow *arg2 = (wxWindow *) 0 ;
34008 PyObject * obj0 = 0 ;
34009 PyObject * obj1 = 0 ;
34010 char *kwnames[] = {
34011 (char *) "self",(char *) "win", NULL
34012 };
34013
34014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34016 if (SWIG_arg_fail(1)) SWIG_fail;
34017 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34018 if (SWIG_arg_fail(2)) SWIG_fail;
34019 {
34020 PyThreadState* __tstate = wxPyBeginAllowThreads();
34021 (arg1)->SetInvokingWindow(arg2);
34022
34023 wxPyEndAllowThreads(__tstate);
34024 if (PyErr_Occurred()) SWIG_fail;
34025 }
34026 Py_INCREF(Py_None); resultobj = Py_None;
34027 return resultobj;
34028 fail:
34029 return NULL;
34030 }
34031
34032
34033 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34034 PyObject *resultobj;
34035 wxMenu *arg1 = (wxMenu *) 0 ;
34036 wxWindow *result;
34037 PyObject * obj0 = 0 ;
34038 char *kwnames[] = {
34039 (char *) "self", NULL
34040 };
34041
34042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34044 if (SWIG_arg_fail(1)) SWIG_fail;
34045 {
34046 PyThreadState* __tstate = wxPyBeginAllowThreads();
34047 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34048
34049 wxPyEndAllowThreads(__tstate);
34050 if (PyErr_Occurred()) SWIG_fail;
34051 }
34052 {
34053 resultobj = wxPyMake_wxObject(result, 0);
34054 }
34055 return resultobj;
34056 fail:
34057 return NULL;
34058 }
34059
34060
34061 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34062 PyObject *resultobj;
34063 wxMenu *arg1 = (wxMenu *) 0 ;
34064 long result;
34065 PyObject * obj0 = 0 ;
34066 char *kwnames[] = {
34067 (char *) "self", NULL
34068 };
34069
34070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34072 if (SWIG_arg_fail(1)) SWIG_fail;
34073 {
34074 PyThreadState* __tstate = wxPyBeginAllowThreads();
34075 result = (long)((wxMenu const *)arg1)->GetStyle();
34076
34077 wxPyEndAllowThreads(__tstate);
34078 if (PyErr_Occurred()) SWIG_fail;
34079 }
34080 {
34081 resultobj = SWIG_From_long((long)(result));
34082 }
34083 return resultobj;
34084 fail:
34085 return NULL;
34086 }
34087
34088
34089 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34090 PyObject *resultobj;
34091 wxMenu *arg1 = (wxMenu *) 0 ;
34092 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34093 PyObject * obj0 = 0 ;
34094 PyObject * obj1 = 0 ;
34095 char *kwnames[] = {
34096 (char *) "self",(char *) "source", NULL
34097 };
34098
34099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34101 if (SWIG_arg_fail(1)) SWIG_fail;
34102 if (obj1) {
34103 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34104 if (SWIG_arg_fail(2)) SWIG_fail;
34105 }
34106 {
34107 PyThreadState* __tstate = wxPyBeginAllowThreads();
34108 (arg1)->UpdateUI(arg2);
34109
34110 wxPyEndAllowThreads(__tstate);
34111 if (PyErr_Occurred()) SWIG_fail;
34112 }
34113 Py_INCREF(Py_None); resultobj = Py_None;
34114 return resultobj;
34115 fail:
34116 return NULL;
34117 }
34118
34119
34120 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34121 PyObject *resultobj;
34122 wxMenu *arg1 = (wxMenu *) 0 ;
34123 wxMenuBar *result;
34124 PyObject * obj0 = 0 ;
34125 char *kwnames[] = {
34126 (char *) "self", NULL
34127 };
34128
34129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34131 if (SWIG_arg_fail(1)) SWIG_fail;
34132 {
34133 PyThreadState* __tstate = wxPyBeginAllowThreads();
34134 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34135
34136 wxPyEndAllowThreads(__tstate);
34137 if (PyErr_Occurred()) SWIG_fail;
34138 }
34139 {
34140 resultobj = wxPyMake_wxObject(result, 0);
34141 }
34142 return resultobj;
34143 fail:
34144 return NULL;
34145 }
34146
34147
34148 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34149 PyObject *resultobj;
34150 wxMenu *arg1 = (wxMenu *) 0 ;
34151 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34152 PyObject * obj0 = 0 ;
34153 PyObject * obj1 = 0 ;
34154 char *kwnames[] = {
34155 (char *) "self",(char *) "menubar", NULL
34156 };
34157
34158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34160 if (SWIG_arg_fail(1)) SWIG_fail;
34161 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34162 if (SWIG_arg_fail(2)) SWIG_fail;
34163 {
34164 PyThreadState* __tstate = wxPyBeginAllowThreads();
34165 (arg1)->Attach(arg2);
34166
34167 wxPyEndAllowThreads(__tstate);
34168 if (PyErr_Occurred()) SWIG_fail;
34169 }
34170 Py_INCREF(Py_None); resultobj = Py_None;
34171 return resultobj;
34172 fail:
34173 return NULL;
34174 }
34175
34176
34177 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34178 PyObject *resultobj;
34179 wxMenu *arg1 = (wxMenu *) 0 ;
34180 PyObject * obj0 = 0 ;
34181 char *kwnames[] = {
34182 (char *) "self", NULL
34183 };
34184
34185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34187 if (SWIG_arg_fail(1)) SWIG_fail;
34188 {
34189 PyThreadState* __tstate = wxPyBeginAllowThreads();
34190 (arg1)->Detach();
34191
34192 wxPyEndAllowThreads(__tstate);
34193 if (PyErr_Occurred()) SWIG_fail;
34194 }
34195 Py_INCREF(Py_None); resultobj = Py_None;
34196 return resultobj;
34197 fail:
34198 return NULL;
34199 }
34200
34201
34202 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34203 PyObject *resultobj;
34204 wxMenu *arg1 = (wxMenu *) 0 ;
34205 bool result;
34206 PyObject * obj0 = 0 ;
34207 char *kwnames[] = {
34208 (char *) "self", NULL
34209 };
34210
34211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34213 if (SWIG_arg_fail(1)) SWIG_fail;
34214 {
34215 PyThreadState* __tstate = wxPyBeginAllowThreads();
34216 result = (bool)((wxMenu const *)arg1)->IsAttached();
34217
34218 wxPyEndAllowThreads(__tstate);
34219 if (PyErr_Occurred()) SWIG_fail;
34220 }
34221 {
34222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34223 }
34224 return resultobj;
34225 fail:
34226 return NULL;
34227 }
34228
34229
34230 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34231 PyObject *resultobj;
34232 wxMenu *arg1 = (wxMenu *) 0 ;
34233 wxMenu *arg2 = (wxMenu *) 0 ;
34234 PyObject * obj0 = 0 ;
34235 PyObject * obj1 = 0 ;
34236 char *kwnames[] = {
34237 (char *) "self",(char *) "parent", NULL
34238 };
34239
34240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34242 if (SWIG_arg_fail(1)) SWIG_fail;
34243 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34244 if (SWIG_arg_fail(2)) SWIG_fail;
34245 {
34246 PyThreadState* __tstate = wxPyBeginAllowThreads();
34247 (arg1)->SetParent(arg2);
34248
34249 wxPyEndAllowThreads(__tstate);
34250 if (PyErr_Occurred()) SWIG_fail;
34251 }
34252 Py_INCREF(Py_None); resultobj = Py_None;
34253 return resultobj;
34254 fail:
34255 return NULL;
34256 }
34257
34258
34259 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34260 PyObject *resultobj;
34261 wxMenu *arg1 = (wxMenu *) 0 ;
34262 wxMenu *result;
34263 PyObject * obj0 = 0 ;
34264 char *kwnames[] = {
34265 (char *) "self", NULL
34266 };
34267
34268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34270 if (SWIG_arg_fail(1)) SWIG_fail;
34271 {
34272 PyThreadState* __tstate = wxPyBeginAllowThreads();
34273 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34274
34275 wxPyEndAllowThreads(__tstate);
34276 if (PyErr_Occurred()) SWIG_fail;
34277 }
34278 {
34279 resultobj = wxPyMake_wxObject(result, 0);
34280 }
34281 return resultobj;
34282 fail:
34283 return NULL;
34284 }
34285
34286
34287 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34288 PyObject *obj;
34289 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34290 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34291 Py_INCREF(obj);
34292 return Py_BuildValue((char *)"");
34293 }
34294 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34295 PyObject *resultobj;
34296 long arg1 = (long) 0 ;
34297 wxMenuBar *result;
34298 PyObject * obj0 = 0 ;
34299 char *kwnames[] = {
34300 (char *) "style", NULL
34301 };
34302
34303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34304 if (obj0) {
34305 {
34306 arg1 = (long)(SWIG_As_long(obj0));
34307 if (SWIG_arg_fail(1)) SWIG_fail;
34308 }
34309 }
34310 {
34311 if (!wxPyCheckForApp()) SWIG_fail;
34312 PyThreadState* __tstate = wxPyBeginAllowThreads();
34313 result = (wxMenuBar *)new wxMenuBar(arg1);
34314
34315 wxPyEndAllowThreads(__tstate);
34316 if (PyErr_Occurred()) SWIG_fail;
34317 }
34318 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34319 return resultobj;
34320 fail:
34321 return NULL;
34322 }
34323
34324
34325 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34326 PyObject *resultobj;
34327 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34328 wxMenu *arg2 = (wxMenu *) 0 ;
34329 wxString *arg3 = 0 ;
34330 bool result;
34331 bool temp3 = false ;
34332 PyObject * obj0 = 0 ;
34333 PyObject * obj1 = 0 ;
34334 PyObject * obj2 = 0 ;
34335 char *kwnames[] = {
34336 (char *) "self",(char *) "menu",(char *) "title", NULL
34337 };
34338
34339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34341 if (SWIG_arg_fail(1)) SWIG_fail;
34342 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34343 if (SWIG_arg_fail(2)) SWIG_fail;
34344 {
34345 arg3 = wxString_in_helper(obj2);
34346 if (arg3 == NULL) SWIG_fail;
34347 temp3 = true;
34348 }
34349 {
34350 PyThreadState* __tstate = wxPyBeginAllowThreads();
34351 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34352
34353 wxPyEndAllowThreads(__tstate);
34354 if (PyErr_Occurred()) SWIG_fail;
34355 }
34356 {
34357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34358 }
34359 {
34360 if (temp3)
34361 delete arg3;
34362 }
34363 return resultobj;
34364 fail:
34365 {
34366 if (temp3)
34367 delete arg3;
34368 }
34369 return NULL;
34370 }
34371
34372
34373 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34374 PyObject *resultobj;
34375 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34376 size_t arg2 ;
34377 wxMenu *arg3 = (wxMenu *) 0 ;
34378 wxString *arg4 = 0 ;
34379 bool result;
34380 bool temp4 = false ;
34381 PyObject * obj0 = 0 ;
34382 PyObject * obj1 = 0 ;
34383 PyObject * obj2 = 0 ;
34384 PyObject * obj3 = 0 ;
34385 char *kwnames[] = {
34386 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34387 };
34388
34389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34391 if (SWIG_arg_fail(1)) SWIG_fail;
34392 {
34393 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34394 if (SWIG_arg_fail(2)) SWIG_fail;
34395 }
34396 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34397 if (SWIG_arg_fail(3)) SWIG_fail;
34398 {
34399 arg4 = wxString_in_helper(obj3);
34400 if (arg4 == NULL) SWIG_fail;
34401 temp4 = true;
34402 }
34403 {
34404 PyThreadState* __tstate = wxPyBeginAllowThreads();
34405 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34406
34407 wxPyEndAllowThreads(__tstate);
34408 if (PyErr_Occurred()) SWIG_fail;
34409 }
34410 {
34411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34412 }
34413 {
34414 if (temp4)
34415 delete arg4;
34416 }
34417 return resultobj;
34418 fail:
34419 {
34420 if (temp4)
34421 delete arg4;
34422 }
34423 return NULL;
34424 }
34425
34426
34427 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34428 PyObject *resultobj;
34429 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34430 size_t result;
34431 PyObject * obj0 = 0 ;
34432 char *kwnames[] = {
34433 (char *) "self", NULL
34434 };
34435
34436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34438 if (SWIG_arg_fail(1)) SWIG_fail;
34439 {
34440 PyThreadState* __tstate = wxPyBeginAllowThreads();
34441 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34442
34443 wxPyEndAllowThreads(__tstate);
34444 if (PyErr_Occurred()) SWIG_fail;
34445 }
34446 {
34447 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34448 }
34449 return resultobj;
34450 fail:
34451 return NULL;
34452 }
34453
34454
34455 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34456 PyObject *resultobj;
34457 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34458 size_t arg2 ;
34459 wxMenu *result;
34460 PyObject * obj0 = 0 ;
34461 PyObject * obj1 = 0 ;
34462 char *kwnames[] = {
34463 (char *) "self",(char *) "pos", NULL
34464 };
34465
34466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34468 if (SWIG_arg_fail(1)) SWIG_fail;
34469 {
34470 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34471 if (SWIG_arg_fail(2)) SWIG_fail;
34472 }
34473 {
34474 PyThreadState* __tstate = wxPyBeginAllowThreads();
34475 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34476
34477 wxPyEndAllowThreads(__tstate);
34478 if (PyErr_Occurred()) SWIG_fail;
34479 }
34480 {
34481 resultobj = wxPyMake_wxObject(result, 0);
34482 }
34483 return resultobj;
34484 fail:
34485 return NULL;
34486 }
34487
34488
34489 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34490 PyObject *resultobj;
34491 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34492 size_t arg2 ;
34493 wxMenu *arg3 = (wxMenu *) 0 ;
34494 wxString *arg4 = 0 ;
34495 wxMenu *result;
34496 bool temp4 = false ;
34497 PyObject * obj0 = 0 ;
34498 PyObject * obj1 = 0 ;
34499 PyObject * obj2 = 0 ;
34500 PyObject * obj3 = 0 ;
34501 char *kwnames[] = {
34502 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34503 };
34504
34505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34507 if (SWIG_arg_fail(1)) SWIG_fail;
34508 {
34509 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34510 if (SWIG_arg_fail(2)) SWIG_fail;
34511 }
34512 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34513 if (SWIG_arg_fail(3)) SWIG_fail;
34514 {
34515 arg4 = wxString_in_helper(obj3);
34516 if (arg4 == NULL) SWIG_fail;
34517 temp4 = true;
34518 }
34519 {
34520 PyThreadState* __tstate = wxPyBeginAllowThreads();
34521 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34522
34523 wxPyEndAllowThreads(__tstate);
34524 if (PyErr_Occurred()) SWIG_fail;
34525 }
34526 {
34527 resultobj = wxPyMake_wxObject(result, 0);
34528 }
34529 {
34530 if (temp4)
34531 delete arg4;
34532 }
34533 return resultobj;
34534 fail:
34535 {
34536 if (temp4)
34537 delete arg4;
34538 }
34539 return NULL;
34540 }
34541
34542
34543 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34544 PyObject *resultobj;
34545 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34546 size_t arg2 ;
34547 wxMenu *result;
34548 PyObject * obj0 = 0 ;
34549 PyObject * obj1 = 0 ;
34550 char *kwnames[] = {
34551 (char *) "self",(char *) "pos", NULL
34552 };
34553
34554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34556 if (SWIG_arg_fail(1)) SWIG_fail;
34557 {
34558 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34559 if (SWIG_arg_fail(2)) SWIG_fail;
34560 }
34561 {
34562 PyThreadState* __tstate = wxPyBeginAllowThreads();
34563 result = (wxMenu *)(arg1)->Remove(arg2);
34564
34565 wxPyEndAllowThreads(__tstate);
34566 if (PyErr_Occurred()) SWIG_fail;
34567 }
34568 {
34569 resultobj = wxPyMake_wxObject(result, 0);
34570 }
34571 return resultobj;
34572 fail:
34573 return NULL;
34574 }
34575
34576
34577 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34578 PyObject *resultobj;
34579 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34580 size_t arg2 ;
34581 bool arg3 ;
34582 PyObject * obj0 = 0 ;
34583 PyObject * obj1 = 0 ;
34584 PyObject * obj2 = 0 ;
34585 char *kwnames[] = {
34586 (char *) "self",(char *) "pos",(char *) "enable", NULL
34587 };
34588
34589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34591 if (SWIG_arg_fail(1)) SWIG_fail;
34592 {
34593 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34594 if (SWIG_arg_fail(2)) SWIG_fail;
34595 }
34596 {
34597 arg3 = (bool)(SWIG_As_bool(obj2));
34598 if (SWIG_arg_fail(3)) SWIG_fail;
34599 }
34600 {
34601 PyThreadState* __tstate = wxPyBeginAllowThreads();
34602 (arg1)->EnableTop(arg2,arg3);
34603
34604 wxPyEndAllowThreads(__tstate);
34605 if (PyErr_Occurred()) SWIG_fail;
34606 }
34607 Py_INCREF(Py_None); resultobj = Py_None;
34608 return resultobj;
34609 fail:
34610 return NULL;
34611 }
34612
34613
34614 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
34615 PyObject *resultobj;
34616 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34617 size_t arg2 ;
34618 bool result;
34619 PyObject * obj0 = 0 ;
34620 PyObject * obj1 = 0 ;
34621 char *kwnames[] = {
34622 (char *) "self",(char *) "pos", NULL
34623 };
34624
34625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
34626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34627 if (SWIG_arg_fail(1)) SWIG_fail;
34628 {
34629 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34630 if (SWIG_arg_fail(2)) SWIG_fail;
34631 }
34632 {
34633 PyThreadState* __tstate = wxPyBeginAllowThreads();
34634 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
34635
34636 wxPyEndAllowThreads(__tstate);
34637 if (PyErr_Occurred()) SWIG_fail;
34638 }
34639 {
34640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34641 }
34642 return resultobj;
34643 fail:
34644 return NULL;
34645 }
34646
34647
34648 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34649 PyObject *resultobj;
34650 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34651 size_t arg2 ;
34652 wxString *arg3 = 0 ;
34653 bool temp3 = false ;
34654 PyObject * obj0 = 0 ;
34655 PyObject * obj1 = 0 ;
34656 PyObject * obj2 = 0 ;
34657 char *kwnames[] = {
34658 (char *) "self",(char *) "pos",(char *) "label", NULL
34659 };
34660
34661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34663 if (SWIG_arg_fail(1)) SWIG_fail;
34664 {
34665 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34666 if (SWIG_arg_fail(2)) SWIG_fail;
34667 }
34668 {
34669 arg3 = wxString_in_helper(obj2);
34670 if (arg3 == NULL) SWIG_fail;
34671 temp3 = true;
34672 }
34673 {
34674 PyThreadState* __tstate = wxPyBeginAllowThreads();
34675 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
34676
34677 wxPyEndAllowThreads(__tstate);
34678 if (PyErr_Occurred()) SWIG_fail;
34679 }
34680 Py_INCREF(Py_None); resultobj = Py_None;
34681 {
34682 if (temp3)
34683 delete arg3;
34684 }
34685 return resultobj;
34686 fail:
34687 {
34688 if (temp3)
34689 delete arg3;
34690 }
34691 return NULL;
34692 }
34693
34694
34695 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34696 PyObject *resultobj;
34697 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34698 size_t arg2 ;
34699 wxString result;
34700 PyObject * obj0 = 0 ;
34701 PyObject * obj1 = 0 ;
34702 char *kwnames[] = {
34703 (char *) "self",(char *) "pos", NULL
34704 };
34705
34706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
34707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34708 if (SWIG_arg_fail(1)) SWIG_fail;
34709 {
34710 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34711 if (SWIG_arg_fail(2)) SWIG_fail;
34712 }
34713 {
34714 PyThreadState* __tstate = wxPyBeginAllowThreads();
34715 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
34716
34717 wxPyEndAllowThreads(__tstate);
34718 if (PyErr_Occurred()) SWIG_fail;
34719 }
34720 {
34721 #if wxUSE_UNICODE
34722 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34723 #else
34724 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34725 #endif
34726 }
34727 return resultobj;
34728 fail:
34729 return NULL;
34730 }
34731
34732
34733 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34734 PyObject *resultobj;
34735 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34736 wxString *arg2 = 0 ;
34737 wxString *arg3 = 0 ;
34738 int result;
34739 bool temp2 = false ;
34740 bool temp3 = false ;
34741 PyObject * obj0 = 0 ;
34742 PyObject * obj1 = 0 ;
34743 PyObject * obj2 = 0 ;
34744 char *kwnames[] = {
34745 (char *) "self",(char *) "menu",(char *) "item", NULL
34746 };
34747
34748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
34749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34750 if (SWIG_arg_fail(1)) SWIG_fail;
34751 {
34752 arg2 = wxString_in_helper(obj1);
34753 if (arg2 == NULL) SWIG_fail;
34754 temp2 = true;
34755 }
34756 {
34757 arg3 = wxString_in_helper(obj2);
34758 if (arg3 == NULL) SWIG_fail;
34759 temp3 = true;
34760 }
34761 {
34762 PyThreadState* __tstate = wxPyBeginAllowThreads();
34763 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
34764
34765 wxPyEndAllowThreads(__tstate);
34766 if (PyErr_Occurred()) SWIG_fail;
34767 }
34768 {
34769 resultobj = SWIG_From_int((int)(result));
34770 }
34771 {
34772 if (temp2)
34773 delete arg2;
34774 }
34775 {
34776 if (temp3)
34777 delete arg3;
34778 }
34779 return resultobj;
34780 fail:
34781 {
34782 if (temp2)
34783 delete arg2;
34784 }
34785 {
34786 if (temp3)
34787 delete arg3;
34788 }
34789 return NULL;
34790 }
34791
34792
34793 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34794 PyObject *resultobj;
34795 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34796 int arg2 ;
34797 wxMenuItem *result;
34798 PyObject * obj0 = 0 ;
34799 PyObject * obj1 = 0 ;
34800 char *kwnames[] = {
34801 (char *) "self",(char *) "id", NULL
34802 };
34803
34804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34806 if (SWIG_arg_fail(1)) SWIG_fail;
34807 {
34808 arg2 = (int)(SWIG_As_int(obj1));
34809 if (SWIG_arg_fail(2)) SWIG_fail;
34810 }
34811 {
34812 PyThreadState* __tstate = wxPyBeginAllowThreads();
34813 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
34814
34815 wxPyEndAllowThreads(__tstate);
34816 if (PyErr_Occurred()) SWIG_fail;
34817 }
34818 {
34819 resultobj = wxPyMake_wxObject(result, 0);
34820 }
34821 return resultobj;
34822 fail:
34823 return NULL;
34824 }
34825
34826
34827 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34828 PyObject *resultobj;
34829 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34830 wxString *arg2 = 0 ;
34831 int result;
34832 bool temp2 = false ;
34833 PyObject * obj0 = 0 ;
34834 PyObject * obj1 = 0 ;
34835 char *kwnames[] = {
34836 (char *) "self",(char *) "title", NULL
34837 };
34838
34839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
34840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34841 if (SWIG_arg_fail(1)) SWIG_fail;
34842 {
34843 arg2 = wxString_in_helper(obj1);
34844 if (arg2 == NULL) SWIG_fail;
34845 temp2 = true;
34846 }
34847 {
34848 PyThreadState* __tstate = wxPyBeginAllowThreads();
34849 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
34850
34851 wxPyEndAllowThreads(__tstate);
34852 if (PyErr_Occurred()) SWIG_fail;
34853 }
34854 {
34855 resultobj = SWIG_From_int((int)(result));
34856 }
34857 {
34858 if (temp2)
34859 delete arg2;
34860 }
34861 return resultobj;
34862 fail:
34863 {
34864 if (temp2)
34865 delete arg2;
34866 }
34867 return NULL;
34868 }
34869
34870
34871 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34872 PyObject *resultobj;
34873 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34874 int arg2 ;
34875 bool arg3 ;
34876 PyObject * obj0 = 0 ;
34877 PyObject * obj1 = 0 ;
34878 PyObject * obj2 = 0 ;
34879 char *kwnames[] = {
34880 (char *) "self",(char *) "id",(char *) "enable", NULL
34881 };
34882
34883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34885 if (SWIG_arg_fail(1)) SWIG_fail;
34886 {
34887 arg2 = (int)(SWIG_As_int(obj1));
34888 if (SWIG_arg_fail(2)) SWIG_fail;
34889 }
34890 {
34891 arg3 = (bool)(SWIG_As_bool(obj2));
34892 if (SWIG_arg_fail(3)) SWIG_fail;
34893 }
34894 {
34895 PyThreadState* __tstate = wxPyBeginAllowThreads();
34896 (arg1)->Enable(arg2,arg3);
34897
34898 wxPyEndAllowThreads(__tstate);
34899 if (PyErr_Occurred()) SWIG_fail;
34900 }
34901 Py_INCREF(Py_None); resultobj = Py_None;
34902 return resultobj;
34903 fail:
34904 return NULL;
34905 }
34906
34907
34908 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34909 PyObject *resultobj;
34910 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34911 int arg2 ;
34912 bool arg3 ;
34913 PyObject * obj0 = 0 ;
34914 PyObject * obj1 = 0 ;
34915 PyObject * obj2 = 0 ;
34916 char *kwnames[] = {
34917 (char *) "self",(char *) "id",(char *) "check", NULL
34918 };
34919
34920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34922 if (SWIG_arg_fail(1)) SWIG_fail;
34923 {
34924 arg2 = (int)(SWIG_As_int(obj1));
34925 if (SWIG_arg_fail(2)) SWIG_fail;
34926 }
34927 {
34928 arg3 = (bool)(SWIG_As_bool(obj2));
34929 if (SWIG_arg_fail(3)) SWIG_fail;
34930 }
34931 {
34932 PyThreadState* __tstate = wxPyBeginAllowThreads();
34933 (arg1)->Check(arg2,arg3);
34934
34935 wxPyEndAllowThreads(__tstate);
34936 if (PyErr_Occurred()) SWIG_fail;
34937 }
34938 Py_INCREF(Py_None); resultobj = Py_None;
34939 return resultobj;
34940 fail:
34941 return NULL;
34942 }
34943
34944
34945 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34946 PyObject *resultobj;
34947 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34948 int arg2 ;
34949 bool result;
34950 PyObject * obj0 = 0 ;
34951 PyObject * obj1 = 0 ;
34952 char *kwnames[] = {
34953 (char *) "self",(char *) "id", NULL
34954 };
34955
34956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34958 if (SWIG_arg_fail(1)) SWIG_fail;
34959 {
34960 arg2 = (int)(SWIG_As_int(obj1));
34961 if (SWIG_arg_fail(2)) SWIG_fail;
34962 }
34963 {
34964 PyThreadState* __tstate = wxPyBeginAllowThreads();
34965 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
34966
34967 wxPyEndAllowThreads(__tstate);
34968 if (PyErr_Occurred()) SWIG_fail;
34969 }
34970 {
34971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34972 }
34973 return resultobj;
34974 fail:
34975 return NULL;
34976 }
34977
34978
34979 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34980 PyObject *resultobj;
34981 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34982 int arg2 ;
34983 bool result;
34984 PyObject * obj0 = 0 ;
34985 PyObject * obj1 = 0 ;
34986 char *kwnames[] = {
34987 (char *) "self",(char *) "id", NULL
34988 };
34989
34990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34992 if (SWIG_arg_fail(1)) SWIG_fail;
34993 {
34994 arg2 = (int)(SWIG_As_int(obj1));
34995 if (SWIG_arg_fail(2)) SWIG_fail;
34996 }
34997 {
34998 PyThreadState* __tstate = wxPyBeginAllowThreads();
34999 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35000
35001 wxPyEndAllowThreads(__tstate);
35002 if (PyErr_Occurred()) SWIG_fail;
35003 }
35004 {
35005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35006 }
35007 return resultobj;
35008 fail:
35009 return NULL;
35010 }
35011
35012
35013 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35014 PyObject *resultobj;
35015 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35016 int arg2 ;
35017 wxString *arg3 = 0 ;
35018 bool temp3 = false ;
35019 PyObject * obj0 = 0 ;
35020 PyObject * obj1 = 0 ;
35021 PyObject * obj2 = 0 ;
35022 char *kwnames[] = {
35023 (char *) "self",(char *) "id",(char *) "label", NULL
35024 };
35025
35026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35028 if (SWIG_arg_fail(1)) SWIG_fail;
35029 {
35030 arg2 = (int)(SWIG_As_int(obj1));
35031 if (SWIG_arg_fail(2)) SWIG_fail;
35032 }
35033 {
35034 arg3 = wxString_in_helper(obj2);
35035 if (arg3 == NULL) SWIG_fail;
35036 temp3 = true;
35037 }
35038 {
35039 PyThreadState* __tstate = wxPyBeginAllowThreads();
35040 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35041
35042 wxPyEndAllowThreads(__tstate);
35043 if (PyErr_Occurred()) SWIG_fail;
35044 }
35045 Py_INCREF(Py_None); resultobj = Py_None;
35046 {
35047 if (temp3)
35048 delete arg3;
35049 }
35050 return resultobj;
35051 fail:
35052 {
35053 if (temp3)
35054 delete arg3;
35055 }
35056 return NULL;
35057 }
35058
35059
35060 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35061 PyObject *resultobj;
35062 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35063 int arg2 ;
35064 wxString result;
35065 PyObject * obj0 = 0 ;
35066 PyObject * obj1 = 0 ;
35067 char *kwnames[] = {
35068 (char *) "self",(char *) "id", NULL
35069 };
35070
35071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35073 if (SWIG_arg_fail(1)) SWIG_fail;
35074 {
35075 arg2 = (int)(SWIG_As_int(obj1));
35076 if (SWIG_arg_fail(2)) SWIG_fail;
35077 }
35078 {
35079 PyThreadState* __tstate = wxPyBeginAllowThreads();
35080 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35081
35082 wxPyEndAllowThreads(__tstate);
35083 if (PyErr_Occurred()) SWIG_fail;
35084 }
35085 {
35086 #if wxUSE_UNICODE
35087 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35088 #else
35089 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35090 #endif
35091 }
35092 return resultobj;
35093 fail:
35094 return NULL;
35095 }
35096
35097
35098 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35099 PyObject *resultobj;
35100 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35101 int arg2 ;
35102 wxString *arg3 = 0 ;
35103 bool temp3 = false ;
35104 PyObject * obj0 = 0 ;
35105 PyObject * obj1 = 0 ;
35106 PyObject * obj2 = 0 ;
35107 char *kwnames[] = {
35108 (char *) "self",(char *) "id",(char *) "helpString", NULL
35109 };
35110
35111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35113 if (SWIG_arg_fail(1)) SWIG_fail;
35114 {
35115 arg2 = (int)(SWIG_As_int(obj1));
35116 if (SWIG_arg_fail(2)) SWIG_fail;
35117 }
35118 {
35119 arg3 = wxString_in_helper(obj2);
35120 if (arg3 == NULL) SWIG_fail;
35121 temp3 = true;
35122 }
35123 {
35124 PyThreadState* __tstate = wxPyBeginAllowThreads();
35125 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35126
35127 wxPyEndAllowThreads(__tstate);
35128 if (PyErr_Occurred()) SWIG_fail;
35129 }
35130 Py_INCREF(Py_None); resultobj = Py_None;
35131 {
35132 if (temp3)
35133 delete arg3;
35134 }
35135 return resultobj;
35136 fail:
35137 {
35138 if (temp3)
35139 delete arg3;
35140 }
35141 return NULL;
35142 }
35143
35144
35145 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35146 PyObject *resultobj;
35147 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35148 int arg2 ;
35149 wxString result;
35150 PyObject * obj0 = 0 ;
35151 PyObject * obj1 = 0 ;
35152 char *kwnames[] = {
35153 (char *) "self",(char *) "id", NULL
35154 };
35155
35156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35158 if (SWIG_arg_fail(1)) SWIG_fail;
35159 {
35160 arg2 = (int)(SWIG_As_int(obj1));
35161 if (SWIG_arg_fail(2)) SWIG_fail;
35162 }
35163 {
35164 PyThreadState* __tstate = wxPyBeginAllowThreads();
35165 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35166
35167 wxPyEndAllowThreads(__tstate);
35168 if (PyErr_Occurred()) SWIG_fail;
35169 }
35170 {
35171 #if wxUSE_UNICODE
35172 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35173 #else
35174 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35175 #endif
35176 }
35177 return resultobj;
35178 fail:
35179 return NULL;
35180 }
35181
35182
35183 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35184 PyObject *resultobj;
35185 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35186 wxFrame *result;
35187 PyObject * obj0 = 0 ;
35188 char *kwnames[] = {
35189 (char *) "self", NULL
35190 };
35191
35192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35194 if (SWIG_arg_fail(1)) SWIG_fail;
35195 {
35196 PyThreadState* __tstate = wxPyBeginAllowThreads();
35197 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35198
35199 wxPyEndAllowThreads(__tstate);
35200 if (PyErr_Occurred()) SWIG_fail;
35201 }
35202 {
35203 resultobj = wxPyMake_wxObject(result, 0);
35204 }
35205 return resultobj;
35206 fail:
35207 return NULL;
35208 }
35209
35210
35211 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35212 PyObject *resultobj;
35213 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35214 bool result;
35215 PyObject * obj0 = 0 ;
35216 char *kwnames[] = {
35217 (char *) "self", NULL
35218 };
35219
35220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35222 if (SWIG_arg_fail(1)) SWIG_fail;
35223 {
35224 PyThreadState* __tstate = wxPyBeginAllowThreads();
35225 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35226
35227 wxPyEndAllowThreads(__tstate);
35228 if (PyErr_Occurred()) SWIG_fail;
35229 }
35230 {
35231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35232 }
35233 return resultobj;
35234 fail:
35235 return NULL;
35236 }
35237
35238
35239 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35240 PyObject *resultobj;
35241 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35242 wxFrame *arg2 = (wxFrame *) 0 ;
35243 PyObject * obj0 = 0 ;
35244 PyObject * obj1 = 0 ;
35245 char *kwnames[] = {
35246 (char *) "self",(char *) "frame", NULL
35247 };
35248
35249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35251 if (SWIG_arg_fail(1)) SWIG_fail;
35252 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35253 if (SWIG_arg_fail(2)) SWIG_fail;
35254 {
35255 PyThreadState* __tstate = wxPyBeginAllowThreads();
35256 (arg1)->Attach(arg2);
35257
35258 wxPyEndAllowThreads(__tstate);
35259 if (PyErr_Occurred()) SWIG_fail;
35260 }
35261 Py_INCREF(Py_None); resultobj = Py_None;
35262 return resultobj;
35263 fail:
35264 return NULL;
35265 }
35266
35267
35268 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35269 PyObject *resultobj;
35270 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35271 PyObject * obj0 = 0 ;
35272 char *kwnames[] = {
35273 (char *) "self", NULL
35274 };
35275
35276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35278 if (SWIG_arg_fail(1)) SWIG_fail;
35279 {
35280 PyThreadState* __tstate = wxPyBeginAllowThreads();
35281 (arg1)->Detach();
35282
35283 wxPyEndAllowThreads(__tstate);
35284 if (PyErr_Occurred()) SWIG_fail;
35285 }
35286 Py_INCREF(Py_None); resultobj = Py_None;
35287 return resultobj;
35288 fail:
35289 return NULL;
35290 }
35291
35292
35293 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35294 PyObject *obj;
35295 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35296 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35297 Py_INCREF(obj);
35298 return Py_BuildValue((char *)"");
35299 }
35300 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35301 PyObject *resultobj;
35302 wxMenu *arg1 = (wxMenu *) NULL ;
35303 int arg2 = (int) wxID_ANY ;
35304 wxString const &arg3_defvalue = wxPyEmptyString ;
35305 wxString *arg3 = (wxString *) &arg3_defvalue ;
35306 wxString const &arg4_defvalue = wxPyEmptyString ;
35307 wxString *arg4 = (wxString *) &arg4_defvalue ;
35308 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35309 wxMenu *arg6 = (wxMenu *) NULL ;
35310 wxMenuItem *result;
35311 bool temp3 = false ;
35312 bool temp4 = false ;
35313 PyObject * obj0 = 0 ;
35314 PyObject * obj1 = 0 ;
35315 PyObject * obj2 = 0 ;
35316 PyObject * obj3 = 0 ;
35317 PyObject * obj4 = 0 ;
35318 PyObject * obj5 = 0 ;
35319 char *kwnames[] = {
35320 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35321 };
35322
35323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35324 if (obj0) {
35325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35326 if (SWIG_arg_fail(1)) SWIG_fail;
35327 }
35328 if (obj1) {
35329 {
35330 arg2 = (int)(SWIG_As_int(obj1));
35331 if (SWIG_arg_fail(2)) SWIG_fail;
35332 }
35333 }
35334 if (obj2) {
35335 {
35336 arg3 = wxString_in_helper(obj2);
35337 if (arg3 == NULL) SWIG_fail;
35338 temp3 = true;
35339 }
35340 }
35341 if (obj3) {
35342 {
35343 arg4 = wxString_in_helper(obj3);
35344 if (arg4 == NULL) SWIG_fail;
35345 temp4 = true;
35346 }
35347 }
35348 if (obj4) {
35349 {
35350 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35351 if (SWIG_arg_fail(5)) SWIG_fail;
35352 }
35353 }
35354 if (obj5) {
35355 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35356 if (SWIG_arg_fail(6)) SWIG_fail;
35357 }
35358 {
35359 PyThreadState* __tstate = wxPyBeginAllowThreads();
35360 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35361
35362 wxPyEndAllowThreads(__tstate);
35363 if (PyErr_Occurred()) SWIG_fail;
35364 }
35365 {
35366 resultobj = wxPyMake_wxObject(result, 1);
35367 }
35368 {
35369 if (temp3)
35370 delete arg3;
35371 }
35372 {
35373 if (temp4)
35374 delete arg4;
35375 }
35376 return resultobj;
35377 fail:
35378 {
35379 if (temp3)
35380 delete arg3;
35381 }
35382 {
35383 if (temp4)
35384 delete arg4;
35385 }
35386 return NULL;
35387 }
35388
35389
35390 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35391 PyObject *resultobj;
35392 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35393 wxMenu *result;
35394 PyObject * obj0 = 0 ;
35395 char *kwnames[] = {
35396 (char *) "self", NULL
35397 };
35398
35399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35401 if (SWIG_arg_fail(1)) SWIG_fail;
35402 {
35403 PyThreadState* __tstate = wxPyBeginAllowThreads();
35404 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35405
35406 wxPyEndAllowThreads(__tstate);
35407 if (PyErr_Occurred()) SWIG_fail;
35408 }
35409 {
35410 resultobj = wxPyMake_wxObject(result, 0);
35411 }
35412 return resultobj;
35413 fail:
35414 return NULL;
35415 }
35416
35417
35418 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35419 PyObject *resultobj;
35420 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35421 wxMenu *arg2 = (wxMenu *) 0 ;
35422 PyObject * obj0 = 0 ;
35423 PyObject * obj1 = 0 ;
35424 char *kwnames[] = {
35425 (char *) "self",(char *) "menu", NULL
35426 };
35427
35428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35430 if (SWIG_arg_fail(1)) SWIG_fail;
35431 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35432 if (SWIG_arg_fail(2)) SWIG_fail;
35433 {
35434 PyThreadState* __tstate = wxPyBeginAllowThreads();
35435 (arg1)->SetMenu(arg2);
35436
35437 wxPyEndAllowThreads(__tstate);
35438 if (PyErr_Occurred()) SWIG_fail;
35439 }
35440 Py_INCREF(Py_None); resultobj = Py_None;
35441 return resultobj;
35442 fail:
35443 return NULL;
35444 }
35445
35446
35447 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35448 PyObject *resultobj;
35449 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35450 int arg2 ;
35451 PyObject * obj0 = 0 ;
35452 PyObject * obj1 = 0 ;
35453 char *kwnames[] = {
35454 (char *) "self",(char *) "id", NULL
35455 };
35456
35457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35459 if (SWIG_arg_fail(1)) SWIG_fail;
35460 {
35461 arg2 = (int)(SWIG_As_int(obj1));
35462 if (SWIG_arg_fail(2)) SWIG_fail;
35463 }
35464 {
35465 PyThreadState* __tstate = wxPyBeginAllowThreads();
35466 (arg1)->SetId(arg2);
35467
35468 wxPyEndAllowThreads(__tstate);
35469 if (PyErr_Occurred()) SWIG_fail;
35470 }
35471 Py_INCREF(Py_None); resultobj = Py_None;
35472 return resultobj;
35473 fail:
35474 return NULL;
35475 }
35476
35477
35478 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35479 PyObject *resultobj;
35480 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35481 int result;
35482 PyObject * obj0 = 0 ;
35483 char *kwnames[] = {
35484 (char *) "self", NULL
35485 };
35486
35487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35489 if (SWIG_arg_fail(1)) SWIG_fail;
35490 {
35491 PyThreadState* __tstate = wxPyBeginAllowThreads();
35492 result = (int)((wxMenuItem const *)arg1)->GetId();
35493
35494 wxPyEndAllowThreads(__tstate);
35495 if (PyErr_Occurred()) SWIG_fail;
35496 }
35497 {
35498 resultobj = SWIG_From_int((int)(result));
35499 }
35500 return resultobj;
35501 fail:
35502 return NULL;
35503 }
35504
35505
35506 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35507 PyObject *resultobj;
35508 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35509 bool result;
35510 PyObject * obj0 = 0 ;
35511 char *kwnames[] = {
35512 (char *) "self", NULL
35513 };
35514
35515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35517 if (SWIG_arg_fail(1)) SWIG_fail;
35518 {
35519 PyThreadState* __tstate = wxPyBeginAllowThreads();
35520 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35521
35522 wxPyEndAllowThreads(__tstate);
35523 if (PyErr_Occurred()) SWIG_fail;
35524 }
35525 {
35526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35527 }
35528 return resultobj;
35529 fail:
35530 return NULL;
35531 }
35532
35533
35534 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35535 PyObject *resultobj;
35536 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35537 wxString *arg2 = 0 ;
35538 bool temp2 = false ;
35539 PyObject * obj0 = 0 ;
35540 PyObject * obj1 = 0 ;
35541 char *kwnames[] = {
35542 (char *) "self",(char *) "str", NULL
35543 };
35544
35545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35547 if (SWIG_arg_fail(1)) SWIG_fail;
35548 {
35549 arg2 = wxString_in_helper(obj1);
35550 if (arg2 == NULL) SWIG_fail;
35551 temp2 = true;
35552 }
35553 {
35554 PyThreadState* __tstate = wxPyBeginAllowThreads();
35555 (arg1)->SetText((wxString const &)*arg2);
35556
35557 wxPyEndAllowThreads(__tstate);
35558 if (PyErr_Occurred()) SWIG_fail;
35559 }
35560 Py_INCREF(Py_None); resultobj = Py_None;
35561 {
35562 if (temp2)
35563 delete arg2;
35564 }
35565 return resultobj;
35566 fail:
35567 {
35568 if (temp2)
35569 delete arg2;
35570 }
35571 return NULL;
35572 }
35573
35574
35575 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35576 PyObject *resultobj;
35577 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35578 wxString result;
35579 PyObject * obj0 = 0 ;
35580 char *kwnames[] = {
35581 (char *) "self", NULL
35582 };
35583
35584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
35585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35586 if (SWIG_arg_fail(1)) SWIG_fail;
35587 {
35588 PyThreadState* __tstate = wxPyBeginAllowThreads();
35589 result = ((wxMenuItem const *)arg1)->GetLabel();
35590
35591 wxPyEndAllowThreads(__tstate);
35592 if (PyErr_Occurred()) SWIG_fail;
35593 }
35594 {
35595 #if wxUSE_UNICODE
35596 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35597 #else
35598 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35599 #endif
35600 }
35601 return resultobj;
35602 fail:
35603 return NULL;
35604 }
35605
35606
35607 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
35608 PyObject *resultobj;
35609 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35610 wxString *result;
35611 PyObject * obj0 = 0 ;
35612 char *kwnames[] = {
35613 (char *) "self", NULL
35614 };
35615
35616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
35617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35618 if (SWIG_arg_fail(1)) SWIG_fail;
35619 {
35620 PyThreadState* __tstate = wxPyBeginAllowThreads();
35621 {
35622 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
35623 result = (wxString *) &_result_ref;
35624 }
35625
35626 wxPyEndAllowThreads(__tstate);
35627 if (PyErr_Occurred()) SWIG_fail;
35628 }
35629 {
35630 #if wxUSE_UNICODE
35631 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35632 #else
35633 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35634 #endif
35635 }
35636 return resultobj;
35637 fail:
35638 return NULL;
35639 }
35640
35641
35642 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
35643 PyObject *resultobj;
35644 wxString *arg1 = 0 ;
35645 wxString result;
35646 bool temp1 = false ;
35647 PyObject * obj0 = 0 ;
35648 char *kwnames[] = {
35649 (char *) "text", NULL
35650 };
35651
35652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
35653 {
35654 arg1 = wxString_in_helper(obj0);
35655 if (arg1 == NULL) SWIG_fail;
35656 temp1 = true;
35657 }
35658 {
35659 PyThreadState* __tstate = wxPyBeginAllowThreads();
35660 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
35661
35662 wxPyEndAllowThreads(__tstate);
35663 if (PyErr_Occurred()) SWIG_fail;
35664 }
35665 {
35666 #if wxUSE_UNICODE
35667 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35668 #else
35669 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35670 #endif
35671 }
35672 {
35673 if (temp1)
35674 delete arg1;
35675 }
35676 return resultobj;
35677 fail:
35678 {
35679 if (temp1)
35680 delete arg1;
35681 }
35682 return NULL;
35683 }
35684
35685
35686 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35687 PyObject *resultobj;
35688 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35689 wxItemKind result;
35690 PyObject * obj0 = 0 ;
35691 char *kwnames[] = {
35692 (char *) "self", NULL
35693 };
35694
35695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
35696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35697 if (SWIG_arg_fail(1)) SWIG_fail;
35698 {
35699 PyThreadState* __tstate = wxPyBeginAllowThreads();
35700 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
35701
35702 wxPyEndAllowThreads(__tstate);
35703 if (PyErr_Occurred()) SWIG_fail;
35704 }
35705 resultobj = SWIG_From_int((result));
35706 return resultobj;
35707 fail:
35708 return NULL;
35709 }
35710
35711
35712 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35713 PyObject *resultobj;
35714 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35715 wxItemKind arg2 ;
35716 PyObject * obj0 = 0 ;
35717 PyObject * obj1 = 0 ;
35718 char *kwnames[] = {
35719 (char *) "self",(char *) "kind", NULL
35720 };
35721
35722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
35723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35724 if (SWIG_arg_fail(1)) SWIG_fail;
35725 {
35726 arg2 = (wxItemKind)(SWIG_As_int(obj1));
35727 if (SWIG_arg_fail(2)) SWIG_fail;
35728 }
35729 {
35730 PyThreadState* __tstate = wxPyBeginAllowThreads();
35731 (arg1)->SetKind((wxItemKind )arg2);
35732
35733 wxPyEndAllowThreads(__tstate);
35734 if (PyErr_Occurred()) SWIG_fail;
35735 }
35736 Py_INCREF(Py_None); resultobj = Py_None;
35737 return resultobj;
35738 fail:
35739 return NULL;
35740 }
35741
35742
35743 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35744 PyObject *resultobj;
35745 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35746 bool arg2 ;
35747 PyObject * obj0 = 0 ;
35748 PyObject * obj1 = 0 ;
35749 char *kwnames[] = {
35750 (char *) "self",(char *) "checkable", NULL
35751 };
35752
35753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
35754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35755 if (SWIG_arg_fail(1)) SWIG_fail;
35756 {
35757 arg2 = (bool)(SWIG_As_bool(obj1));
35758 if (SWIG_arg_fail(2)) SWIG_fail;
35759 }
35760 {
35761 PyThreadState* __tstate = wxPyBeginAllowThreads();
35762 (arg1)->SetCheckable(arg2);
35763
35764 wxPyEndAllowThreads(__tstate);
35765 if (PyErr_Occurred()) SWIG_fail;
35766 }
35767 Py_INCREF(Py_None); resultobj = Py_None;
35768 return resultobj;
35769 fail:
35770 return NULL;
35771 }
35772
35773
35774 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35775 PyObject *resultobj;
35776 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35777 bool result;
35778 PyObject * obj0 = 0 ;
35779 char *kwnames[] = {
35780 (char *) "self", NULL
35781 };
35782
35783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
35784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35785 if (SWIG_arg_fail(1)) SWIG_fail;
35786 {
35787 PyThreadState* __tstate = wxPyBeginAllowThreads();
35788 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
35789
35790 wxPyEndAllowThreads(__tstate);
35791 if (PyErr_Occurred()) SWIG_fail;
35792 }
35793 {
35794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35795 }
35796 return resultobj;
35797 fail:
35798 return NULL;
35799 }
35800
35801
35802 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35803 PyObject *resultobj;
35804 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35805 bool result;
35806 PyObject * obj0 = 0 ;
35807 char *kwnames[] = {
35808 (char *) "self", NULL
35809 };
35810
35811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
35812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35813 if (SWIG_arg_fail(1)) SWIG_fail;
35814 {
35815 PyThreadState* __tstate = wxPyBeginAllowThreads();
35816 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
35817
35818 wxPyEndAllowThreads(__tstate);
35819 if (PyErr_Occurred()) SWIG_fail;
35820 }
35821 {
35822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35823 }
35824 return resultobj;
35825 fail:
35826 return NULL;
35827 }
35828
35829
35830 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35831 PyObject *resultobj;
35832 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35833 wxMenu *arg2 = (wxMenu *) 0 ;
35834 PyObject * obj0 = 0 ;
35835 PyObject * obj1 = 0 ;
35836 char *kwnames[] = {
35837 (char *) "self",(char *) "menu", NULL
35838 };
35839
35840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
35841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35842 if (SWIG_arg_fail(1)) SWIG_fail;
35843 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35844 if (SWIG_arg_fail(2)) SWIG_fail;
35845 {
35846 PyThreadState* __tstate = wxPyBeginAllowThreads();
35847 (arg1)->SetSubMenu(arg2);
35848
35849 wxPyEndAllowThreads(__tstate);
35850 if (PyErr_Occurred()) SWIG_fail;
35851 }
35852 Py_INCREF(Py_None); resultobj = Py_None;
35853 return resultobj;
35854 fail:
35855 return NULL;
35856 }
35857
35858
35859 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35860 PyObject *resultobj;
35861 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35862 wxMenu *result;
35863 PyObject * obj0 = 0 ;
35864 char *kwnames[] = {
35865 (char *) "self", NULL
35866 };
35867
35868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
35869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35870 if (SWIG_arg_fail(1)) SWIG_fail;
35871 {
35872 PyThreadState* __tstate = wxPyBeginAllowThreads();
35873 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
35874
35875 wxPyEndAllowThreads(__tstate);
35876 if (PyErr_Occurred()) SWIG_fail;
35877 }
35878 {
35879 resultobj = wxPyMake_wxObject(result, 0);
35880 }
35881 return resultobj;
35882 fail:
35883 return NULL;
35884 }
35885
35886
35887 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35888 PyObject *resultobj;
35889 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35890 bool arg2 = (bool) true ;
35891 PyObject * obj0 = 0 ;
35892 PyObject * obj1 = 0 ;
35893 char *kwnames[] = {
35894 (char *) "self",(char *) "enable", NULL
35895 };
35896
35897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
35898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35899 if (SWIG_arg_fail(1)) SWIG_fail;
35900 if (obj1) {
35901 {
35902 arg2 = (bool)(SWIG_As_bool(obj1));
35903 if (SWIG_arg_fail(2)) SWIG_fail;
35904 }
35905 }
35906 {
35907 PyThreadState* __tstate = wxPyBeginAllowThreads();
35908 (arg1)->Enable(arg2);
35909
35910 wxPyEndAllowThreads(__tstate);
35911 if (PyErr_Occurred()) SWIG_fail;
35912 }
35913 Py_INCREF(Py_None); resultobj = Py_None;
35914 return resultobj;
35915 fail:
35916 return NULL;
35917 }
35918
35919
35920 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35921 PyObject *resultobj;
35922 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35923 bool result;
35924 PyObject * obj0 = 0 ;
35925 char *kwnames[] = {
35926 (char *) "self", NULL
35927 };
35928
35929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
35930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35931 if (SWIG_arg_fail(1)) SWIG_fail;
35932 {
35933 PyThreadState* __tstate = wxPyBeginAllowThreads();
35934 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
35935
35936 wxPyEndAllowThreads(__tstate);
35937 if (PyErr_Occurred()) SWIG_fail;
35938 }
35939 {
35940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35941 }
35942 return resultobj;
35943 fail:
35944 return NULL;
35945 }
35946
35947
35948 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35949 PyObject *resultobj;
35950 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35951 bool arg2 = (bool) true ;
35952 PyObject * obj0 = 0 ;
35953 PyObject * obj1 = 0 ;
35954 char *kwnames[] = {
35955 (char *) "self",(char *) "check", NULL
35956 };
35957
35958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
35959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35960 if (SWIG_arg_fail(1)) SWIG_fail;
35961 if (obj1) {
35962 {
35963 arg2 = (bool)(SWIG_As_bool(obj1));
35964 if (SWIG_arg_fail(2)) SWIG_fail;
35965 }
35966 }
35967 {
35968 PyThreadState* __tstate = wxPyBeginAllowThreads();
35969 (arg1)->Check(arg2);
35970
35971 wxPyEndAllowThreads(__tstate);
35972 if (PyErr_Occurred()) SWIG_fail;
35973 }
35974 Py_INCREF(Py_None); resultobj = Py_None;
35975 return resultobj;
35976 fail:
35977 return NULL;
35978 }
35979
35980
35981 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35982 PyObject *resultobj;
35983 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35984 bool result;
35985 PyObject * obj0 = 0 ;
35986 char *kwnames[] = {
35987 (char *) "self", NULL
35988 };
35989
35990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
35991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35992 if (SWIG_arg_fail(1)) SWIG_fail;
35993 {
35994 PyThreadState* __tstate = wxPyBeginAllowThreads();
35995 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
35996
35997 wxPyEndAllowThreads(__tstate);
35998 if (PyErr_Occurred()) SWIG_fail;
35999 }
36000 {
36001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36002 }
36003 return resultobj;
36004 fail:
36005 return NULL;
36006 }
36007
36008
36009 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36010 PyObject *resultobj;
36011 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36012 PyObject * obj0 = 0 ;
36013 char *kwnames[] = {
36014 (char *) "self", NULL
36015 };
36016
36017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36019 if (SWIG_arg_fail(1)) SWIG_fail;
36020 {
36021 PyThreadState* __tstate = wxPyBeginAllowThreads();
36022 (arg1)->Toggle();
36023
36024 wxPyEndAllowThreads(__tstate);
36025 if (PyErr_Occurred()) SWIG_fail;
36026 }
36027 Py_INCREF(Py_None); resultobj = Py_None;
36028 return resultobj;
36029 fail:
36030 return NULL;
36031 }
36032
36033
36034 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36035 PyObject *resultobj;
36036 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36037 wxString *arg2 = 0 ;
36038 bool temp2 = false ;
36039 PyObject * obj0 = 0 ;
36040 PyObject * obj1 = 0 ;
36041 char *kwnames[] = {
36042 (char *) "self",(char *) "str", NULL
36043 };
36044
36045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36047 if (SWIG_arg_fail(1)) SWIG_fail;
36048 {
36049 arg2 = wxString_in_helper(obj1);
36050 if (arg2 == NULL) SWIG_fail;
36051 temp2 = true;
36052 }
36053 {
36054 PyThreadState* __tstate = wxPyBeginAllowThreads();
36055 (arg1)->SetHelp((wxString const &)*arg2);
36056
36057 wxPyEndAllowThreads(__tstate);
36058 if (PyErr_Occurred()) SWIG_fail;
36059 }
36060 Py_INCREF(Py_None); resultobj = Py_None;
36061 {
36062 if (temp2)
36063 delete arg2;
36064 }
36065 return resultobj;
36066 fail:
36067 {
36068 if (temp2)
36069 delete arg2;
36070 }
36071 return NULL;
36072 }
36073
36074
36075 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36076 PyObject *resultobj;
36077 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36078 wxString *result;
36079 PyObject * obj0 = 0 ;
36080 char *kwnames[] = {
36081 (char *) "self", NULL
36082 };
36083
36084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36086 if (SWIG_arg_fail(1)) SWIG_fail;
36087 {
36088 PyThreadState* __tstate = wxPyBeginAllowThreads();
36089 {
36090 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36091 result = (wxString *) &_result_ref;
36092 }
36093
36094 wxPyEndAllowThreads(__tstate);
36095 if (PyErr_Occurred()) SWIG_fail;
36096 }
36097 {
36098 #if wxUSE_UNICODE
36099 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36100 #else
36101 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36102 #endif
36103 }
36104 return resultobj;
36105 fail:
36106 return NULL;
36107 }
36108
36109
36110 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36111 PyObject *resultobj;
36112 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36113 wxAcceleratorEntry *result;
36114 PyObject * obj0 = 0 ;
36115 char *kwnames[] = {
36116 (char *) "self", NULL
36117 };
36118
36119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36121 if (SWIG_arg_fail(1)) SWIG_fail;
36122 {
36123 PyThreadState* __tstate = wxPyBeginAllowThreads();
36124 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36125
36126 wxPyEndAllowThreads(__tstate);
36127 if (PyErr_Occurred()) SWIG_fail;
36128 }
36129 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36130 return resultobj;
36131 fail:
36132 return NULL;
36133 }
36134
36135
36136 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36137 PyObject *resultobj;
36138 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36139 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36140 PyObject * obj0 = 0 ;
36141 PyObject * obj1 = 0 ;
36142 char *kwnames[] = {
36143 (char *) "self",(char *) "accel", NULL
36144 };
36145
36146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36148 if (SWIG_arg_fail(1)) SWIG_fail;
36149 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36150 if (SWIG_arg_fail(2)) SWIG_fail;
36151 {
36152 PyThreadState* __tstate = wxPyBeginAllowThreads();
36153 (arg1)->SetAccel(arg2);
36154
36155 wxPyEndAllowThreads(__tstate);
36156 if (PyErr_Occurred()) SWIG_fail;
36157 }
36158 Py_INCREF(Py_None); resultobj = Py_None;
36159 return resultobj;
36160 fail:
36161 return NULL;
36162 }
36163
36164
36165 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36166 PyObject *resultobj;
36167 int result;
36168 char *kwnames[] = {
36169 NULL
36170 };
36171
36172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
36173 {
36174 PyThreadState* __tstate = wxPyBeginAllowThreads();
36175 result = (int)MenuItem_GetDefaultMarginWidth();
36176
36177 wxPyEndAllowThreads(__tstate);
36178 if (PyErr_Occurred()) SWIG_fail;
36179 }
36180 {
36181 resultobj = SWIG_From_int((int)(result));
36182 }
36183 return resultobj;
36184 fail:
36185 return NULL;
36186 }
36187
36188
36189 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36190 PyObject *resultobj;
36191 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36192 wxBitmap *arg2 = 0 ;
36193 PyObject * obj0 = 0 ;
36194 PyObject * obj1 = 0 ;
36195 char *kwnames[] = {
36196 (char *) "self",(char *) "bitmap", NULL
36197 };
36198
36199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
36200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36201 if (SWIG_arg_fail(1)) SWIG_fail;
36202 {
36203 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36204 if (SWIG_arg_fail(2)) SWIG_fail;
36205 if (arg2 == NULL) {
36206 SWIG_null_ref("wxBitmap");
36207 }
36208 if (SWIG_arg_fail(2)) SWIG_fail;
36209 }
36210 {
36211 PyThreadState* __tstate = wxPyBeginAllowThreads();
36212 (arg1)->SetBitmap((wxBitmap const &)*arg2);
36213
36214 wxPyEndAllowThreads(__tstate);
36215 if (PyErr_Occurred()) SWIG_fail;
36216 }
36217 Py_INCREF(Py_None); resultobj = Py_None;
36218 return resultobj;
36219 fail:
36220 return NULL;
36221 }
36222
36223
36224 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36225 PyObject *resultobj;
36226 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36227 wxBitmap *result;
36228 PyObject * obj0 = 0 ;
36229 char *kwnames[] = {
36230 (char *) "self", NULL
36231 };
36232
36233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
36234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36235 if (SWIG_arg_fail(1)) SWIG_fail;
36236 {
36237 PyThreadState* __tstate = wxPyBeginAllowThreads();
36238 {
36239 wxBitmap const &_result_ref = (arg1)->GetBitmap();
36240 result = (wxBitmap *) &_result_ref;
36241 }
36242
36243 wxPyEndAllowThreads(__tstate);
36244 if (PyErr_Occurred()) SWIG_fail;
36245 }
36246 {
36247 wxBitmap* resultptr = new wxBitmap(*result);
36248 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36249 }
36250 return resultobj;
36251 fail:
36252 return NULL;
36253 }
36254
36255
36256 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
36257 PyObject *obj;
36258 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36259 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
36260 Py_INCREF(obj);
36261 return Py_BuildValue((char *)"");
36262 }
36263 static int _wrap_ControlNameStr_set(PyObject *) {
36264 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
36265 return 1;
36266 }
36267
36268
36269 static PyObject *_wrap_ControlNameStr_get(void) {
36270 PyObject *pyobj;
36271
36272 {
36273 #if wxUSE_UNICODE
36274 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36275 #else
36276 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36277 #endif
36278 }
36279 return pyobj;
36280 }
36281
36282
36283 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
36284 PyObject *resultobj;
36285 wxWindow *arg1 = (wxWindow *) 0 ;
36286 int arg2 = (int) -1 ;
36287 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36288 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36289 wxSize const &arg4_defvalue = wxDefaultSize ;
36290 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
36291 long arg5 = (long) 0 ;
36292 wxValidator const &arg6_defvalue = wxDefaultValidator ;
36293 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
36294 wxString const &arg7_defvalue = wxPyControlNameStr ;
36295 wxString *arg7 = (wxString *) &arg7_defvalue ;
36296 wxControl *result;
36297 wxPoint temp3 ;
36298 wxSize temp4 ;
36299 bool temp7 = false ;
36300 PyObject * obj0 = 0 ;
36301 PyObject * obj1 = 0 ;
36302 PyObject * obj2 = 0 ;
36303 PyObject * obj3 = 0 ;
36304 PyObject * obj4 = 0 ;
36305 PyObject * obj5 = 0 ;
36306 PyObject * obj6 = 0 ;
36307 char *kwnames[] = {
36308 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36309 };
36310
36311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
36312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36313 if (SWIG_arg_fail(1)) SWIG_fail;
36314 if (obj1) {
36315 {
36316 arg2 = (int)(SWIG_As_int(obj1));
36317 if (SWIG_arg_fail(2)) SWIG_fail;
36318 }
36319 }
36320 if (obj2) {
36321 {
36322 arg3 = &temp3;
36323 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36324 }
36325 }
36326 if (obj3) {
36327 {
36328 arg4 = &temp4;
36329 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
36330 }
36331 }
36332 if (obj4) {
36333 {
36334 arg5 = (long)(SWIG_As_long(obj4));
36335 if (SWIG_arg_fail(5)) SWIG_fail;
36336 }
36337 }
36338 if (obj5) {
36339 {
36340 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36341 if (SWIG_arg_fail(6)) SWIG_fail;
36342 if (arg6 == NULL) {
36343 SWIG_null_ref("wxValidator");
36344 }
36345 if (SWIG_arg_fail(6)) SWIG_fail;
36346 }
36347 }
36348 if (obj6) {
36349 {
36350 arg7 = wxString_in_helper(obj6);
36351 if (arg7 == NULL) SWIG_fail;
36352 temp7 = true;
36353 }
36354 }
36355 {
36356 if (!wxPyCheckForApp()) SWIG_fail;
36357 PyThreadState* __tstate = wxPyBeginAllowThreads();
36358 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
36359
36360 wxPyEndAllowThreads(__tstate);
36361 if (PyErr_Occurred()) SWIG_fail;
36362 }
36363 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36364 {
36365 if (temp7)
36366 delete arg7;
36367 }
36368 return resultobj;
36369 fail:
36370 {
36371 if (temp7)
36372 delete arg7;
36373 }
36374 return NULL;
36375 }
36376
36377
36378 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
36379 PyObject *resultobj;
36380 wxControl *result;
36381 char *kwnames[] = {
36382 NULL
36383 };
36384
36385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
36386 {
36387 if (!wxPyCheckForApp()) SWIG_fail;
36388 PyThreadState* __tstate = wxPyBeginAllowThreads();
36389 result = (wxControl *)new wxControl();
36390
36391 wxPyEndAllowThreads(__tstate);
36392 if (PyErr_Occurred()) SWIG_fail;
36393 }
36394 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36395 return resultobj;
36396 fail:
36397 return NULL;
36398 }
36399
36400
36401 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
36402 PyObject *resultobj;
36403 wxControl *arg1 = (wxControl *) 0 ;
36404 wxWindow *arg2 = (wxWindow *) 0 ;
36405 int arg3 = (int) -1 ;
36406 wxPoint const &arg4_defvalue = wxDefaultPosition ;
36407 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
36408 wxSize const &arg5_defvalue = wxDefaultSize ;
36409 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
36410 long arg6 = (long) 0 ;
36411 wxValidator const &arg7_defvalue = wxDefaultValidator ;
36412 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
36413 wxString const &arg8_defvalue = wxPyControlNameStr ;
36414 wxString *arg8 = (wxString *) &arg8_defvalue ;
36415 bool result;
36416 wxPoint temp4 ;
36417 wxSize temp5 ;
36418 bool temp8 = false ;
36419 PyObject * obj0 = 0 ;
36420 PyObject * obj1 = 0 ;
36421 PyObject * obj2 = 0 ;
36422 PyObject * obj3 = 0 ;
36423 PyObject * obj4 = 0 ;
36424 PyObject * obj5 = 0 ;
36425 PyObject * obj6 = 0 ;
36426 PyObject * obj7 = 0 ;
36427 char *kwnames[] = {
36428 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36429 };
36430
36431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
36432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36433 if (SWIG_arg_fail(1)) SWIG_fail;
36434 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36435 if (SWIG_arg_fail(2)) SWIG_fail;
36436 if (obj2) {
36437 {
36438 arg3 = (int)(SWIG_As_int(obj2));
36439 if (SWIG_arg_fail(3)) SWIG_fail;
36440 }
36441 }
36442 if (obj3) {
36443 {
36444 arg4 = &temp4;
36445 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
36446 }
36447 }
36448 if (obj4) {
36449 {
36450 arg5 = &temp5;
36451 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
36452 }
36453 }
36454 if (obj5) {
36455 {
36456 arg6 = (long)(SWIG_As_long(obj5));
36457 if (SWIG_arg_fail(6)) SWIG_fail;
36458 }
36459 }
36460 if (obj6) {
36461 {
36462 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36463 if (SWIG_arg_fail(7)) SWIG_fail;
36464 if (arg7 == NULL) {
36465 SWIG_null_ref("wxValidator");
36466 }
36467 if (SWIG_arg_fail(7)) SWIG_fail;
36468 }
36469 }
36470 if (obj7) {
36471 {
36472 arg8 = wxString_in_helper(obj7);
36473 if (arg8 == NULL) SWIG_fail;
36474 temp8 = true;
36475 }
36476 }
36477 {
36478 PyThreadState* __tstate = wxPyBeginAllowThreads();
36479 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
36480
36481 wxPyEndAllowThreads(__tstate);
36482 if (PyErr_Occurred()) SWIG_fail;
36483 }
36484 {
36485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36486 }
36487 {
36488 if (temp8)
36489 delete arg8;
36490 }
36491 return resultobj;
36492 fail:
36493 {
36494 if (temp8)
36495 delete arg8;
36496 }
36497 return NULL;
36498 }
36499
36500
36501 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
36502 PyObject *resultobj;
36503 wxControl *arg1 = (wxControl *) 0 ;
36504 wxCommandEvent *arg2 = 0 ;
36505 PyObject * obj0 = 0 ;
36506 PyObject * obj1 = 0 ;
36507 char *kwnames[] = {
36508 (char *) "self",(char *) "event", NULL
36509 };
36510
36511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
36512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36513 if (SWIG_arg_fail(1)) SWIG_fail;
36514 {
36515 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
36516 if (SWIG_arg_fail(2)) SWIG_fail;
36517 if (arg2 == NULL) {
36518 SWIG_null_ref("wxCommandEvent");
36519 }
36520 if (SWIG_arg_fail(2)) SWIG_fail;
36521 }
36522 {
36523 PyThreadState* __tstate = wxPyBeginAllowThreads();
36524 (arg1)->Command(*arg2);
36525
36526 wxPyEndAllowThreads(__tstate);
36527 if (PyErr_Occurred()) SWIG_fail;
36528 }
36529 Py_INCREF(Py_None); resultobj = Py_None;
36530 return resultobj;
36531 fail:
36532 return NULL;
36533 }
36534
36535
36536 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36537 PyObject *resultobj;
36538 wxControl *arg1 = (wxControl *) 0 ;
36539 wxString result;
36540 PyObject * obj0 = 0 ;
36541 char *kwnames[] = {
36542 (char *) "self", NULL
36543 };
36544
36545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
36546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36547 if (SWIG_arg_fail(1)) SWIG_fail;
36548 {
36549 PyThreadState* __tstate = wxPyBeginAllowThreads();
36550 result = (arg1)->GetLabel();
36551
36552 wxPyEndAllowThreads(__tstate);
36553 if (PyErr_Occurred()) SWIG_fail;
36554 }
36555 {
36556 #if wxUSE_UNICODE
36557 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36558 #else
36559 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36560 #endif
36561 }
36562 return resultobj;
36563 fail:
36564 return NULL;
36565 }
36566
36567
36568 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36569 PyObject *resultobj;
36570 wxControl *arg1 = (wxControl *) 0 ;
36571 wxString *arg2 = 0 ;
36572 bool temp2 = false ;
36573 PyObject * obj0 = 0 ;
36574 PyObject * obj1 = 0 ;
36575 char *kwnames[] = {
36576 (char *) "self",(char *) "label", NULL
36577 };
36578
36579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
36580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36581 if (SWIG_arg_fail(1)) SWIG_fail;
36582 {
36583 arg2 = wxString_in_helper(obj1);
36584 if (arg2 == NULL) SWIG_fail;
36585 temp2 = true;
36586 }
36587 {
36588 PyThreadState* __tstate = wxPyBeginAllowThreads();
36589 (arg1)->SetLabel((wxString const &)*arg2);
36590
36591 wxPyEndAllowThreads(__tstate);
36592 if (PyErr_Occurred()) SWIG_fail;
36593 }
36594 Py_INCREF(Py_None); resultobj = Py_None;
36595 {
36596 if (temp2)
36597 delete arg2;
36598 }
36599 return resultobj;
36600 fail:
36601 {
36602 if (temp2)
36603 delete arg2;
36604 }
36605 return NULL;
36606 }
36607
36608
36609 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
36610 PyObject *resultobj;
36611 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
36612 wxVisualAttributes result;
36613 PyObject * obj0 = 0 ;
36614 char *kwnames[] = {
36615 (char *) "variant", NULL
36616 };
36617
36618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
36619 if (obj0) {
36620 {
36621 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
36622 if (SWIG_arg_fail(1)) SWIG_fail;
36623 }
36624 }
36625 {
36626 if (!wxPyCheckForApp()) SWIG_fail;
36627 PyThreadState* __tstate = wxPyBeginAllowThreads();
36628 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
36629
36630 wxPyEndAllowThreads(__tstate);
36631 if (PyErr_Occurred()) SWIG_fail;
36632 }
36633 {
36634 wxVisualAttributes * resultptr;
36635 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
36636 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
36637 }
36638 return resultobj;
36639 fail:
36640 return NULL;
36641 }
36642
36643
36644 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
36645 PyObject *obj;
36646 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36647 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
36648 Py_INCREF(obj);
36649 return Py_BuildValue((char *)"");
36650 }
36651 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
36652 PyObject *resultobj;
36653 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36654 wxString *arg2 = 0 ;
36655 PyObject *arg3 = (PyObject *) NULL ;
36656 int result;
36657 bool temp2 = false ;
36658 PyObject * obj0 = 0 ;
36659 PyObject * obj1 = 0 ;
36660 PyObject * obj2 = 0 ;
36661 char *kwnames[] = {
36662 (char *) "self",(char *) "item",(char *) "clientData", NULL
36663 };
36664
36665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
36666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36667 if (SWIG_arg_fail(1)) SWIG_fail;
36668 {
36669 arg2 = wxString_in_helper(obj1);
36670 if (arg2 == NULL) SWIG_fail;
36671 temp2 = true;
36672 }
36673 if (obj2) {
36674 arg3 = obj2;
36675 }
36676 {
36677 PyThreadState* __tstate = wxPyBeginAllowThreads();
36678 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
36679
36680 wxPyEndAllowThreads(__tstate);
36681 if (PyErr_Occurred()) SWIG_fail;
36682 }
36683 {
36684 resultobj = SWIG_From_int((int)(result));
36685 }
36686 {
36687 if (temp2)
36688 delete arg2;
36689 }
36690 return resultobj;
36691 fail:
36692 {
36693 if (temp2)
36694 delete arg2;
36695 }
36696 return NULL;
36697 }
36698
36699
36700 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
36701 PyObject *resultobj;
36702 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36703 wxArrayString *arg2 = 0 ;
36704 bool temp2 = false ;
36705 PyObject * obj0 = 0 ;
36706 PyObject * obj1 = 0 ;
36707 char *kwnames[] = {
36708 (char *) "self",(char *) "strings", NULL
36709 };
36710
36711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
36712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36713 if (SWIG_arg_fail(1)) SWIG_fail;
36714 {
36715 if (! PySequence_Check(obj1)) {
36716 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
36717 SWIG_fail;
36718 }
36719 arg2 = new wxArrayString;
36720 temp2 = true;
36721 int i, len=PySequence_Length(obj1);
36722 for (i=0; i<len; i++) {
36723 PyObject* item = PySequence_GetItem(obj1, i);
36724 #if wxUSE_UNICODE
36725 PyObject* str = PyObject_Unicode(item);
36726 #else
36727 PyObject* str = PyObject_Str(item);
36728 #endif
36729 if (PyErr_Occurred()) SWIG_fail;
36730 arg2->Add(Py2wxString(str));
36731 Py_DECREF(item);
36732 Py_DECREF(str);
36733 }
36734 }
36735 {
36736 PyThreadState* __tstate = wxPyBeginAllowThreads();
36737 (arg1)->Append((wxArrayString const &)*arg2);
36738
36739 wxPyEndAllowThreads(__tstate);
36740 if (PyErr_Occurred()) SWIG_fail;
36741 }
36742 Py_INCREF(Py_None); resultobj = Py_None;
36743 {
36744 if (temp2) delete arg2;
36745 }
36746 return resultobj;
36747 fail:
36748 {
36749 if (temp2) delete arg2;
36750 }
36751 return NULL;
36752 }
36753
36754
36755 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
36756 PyObject *resultobj;
36757 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36758 wxString *arg2 = 0 ;
36759 int arg3 ;
36760 PyObject *arg4 = (PyObject *) NULL ;
36761 int result;
36762 bool temp2 = false ;
36763 PyObject * obj0 = 0 ;
36764 PyObject * obj1 = 0 ;
36765 PyObject * obj2 = 0 ;
36766 PyObject * obj3 = 0 ;
36767 char *kwnames[] = {
36768 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
36769 };
36770
36771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
36772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36773 if (SWIG_arg_fail(1)) SWIG_fail;
36774 {
36775 arg2 = wxString_in_helper(obj1);
36776 if (arg2 == NULL) SWIG_fail;
36777 temp2 = true;
36778 }
36779 {
36780 arg3 = (int)(SWIG_As_int(obj2));
36781 if (SWIG_arg_fail(3)) SWIG_fail;
36782 }
36783 if (obj3) {
36784 arg4 = obj3;
36785 }
36786 {
36787 PyThreadState* __tstate = wxPyBeginAllowThreads();
36788 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
36789
36790 wxPyEndAllowThreads(__tstate);
36791 if (PyErr_Occurred()) SWIG_fail;
36792 }
36793 {
36794 resultobj = SWIG_From_int((int)(result));
36795 }
36796 {
36797 if (temp2)
36798 delete arg2;
36799 }
36800 return resultobj;
36801 fail:
36802 {
36803 if (temp2)
36804 delete arg2;
36805 }
36806 return NULL;
36807 }
36808
36809
36810 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
36811 PyObject *resultobj;
36812 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36813 PyObject * obj0 = 0 ;
36814 char *kwnames[] = {
36815 (char *) "self", NULL
36816 };
36817
36818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
36819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36820 if (SWIG_arg_fail(1)) SWIG_fail;
36821 {
36822 PyThreadState* __tstate = wxPyBeginAllowThreads();
36823 (arg1)->Clear();
36824
36825 wxPyEndAllowThreads(__tstate);
36826 if (PyErr_Occurred()) SWIG_fail;
36827 }
36828 Py_INCREF(Py_None); resultobj = Py_None;
36829 return resultobj;
36830 fail:
36831 return NULL;
36832 }
36833
36834
36835 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
36836 PyObject *resultobj;
36837 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36838 int arg2 ;
36839 PyObject * obj0 = 0 ;
36840 PyObject * obj1 = 0 ;
36841 char *kwnames[] = {
36842 (char *) "self",(char *) "n", NULL
36843 };
36844
36845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
36846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36847 if (SWIG_arg_fail(1)) SWIG_fail;
36848 {
36849 arg2 = (int)(SWIG_As_int(obj1));
36850 if (SWIG_arg_fail(2)) SWIG_fail;
36851 }
36852 {
36853 PyThreadState* __tstate = wxPyBeginAllowThreads();
36854 (arg1)->Delete(arg2);
36855
36856 wxPyEndAllowThreads(__tstate);
36857 if (PyErr_Occurred()) SWIG_fail;
36858 }
36859 Py_INCREF(Py_None); resultobj = Py_None;
36860 return resultobj;
36861 fail:
36862 return NULL;
36863 }
36864
36865
36866 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
36867 PyObject *resultobj;
36868 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36869 int arg2 ;
36870 PyObject *result;
36871 PyObject * obj0 = 0 ;
36872 PyObject * obj1 = 0 ;
36873 char *kwnames[] = {
36874 (char *) "self",(char *) "n", NULL
36875 };
36876
36877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
36878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36879 if (SWIG_arg_fail(1)) SWIG_fail;
36880 {
36881 arg2 = (int)(SWIG_As_int(obj1));
36882 if (SWIG_arg_fail(2)) SWIG_fail;
36883 }
36884 {
36885 PyThreadState* __tstate = wxPyBeginAllowThreads();
36886 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
36887
36888 wxPyEndAllowThreads(__tstate);
36889 if (PyErr_Occurred()) SWIG_fail;
36890 }
36891 resultobj = result;
36892 return resultobj;
36893 fail:
36894 return NULL;
36895 }
36896
36897
36898 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
36899 PyObject *resultobj;
36900 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36901 int arg2 ;
36902 PyObject *arg3 = (PyObject *) 0 ;
36903 PyObject * obj0 = 0 ;
36904 PyObject * obj1 = 0 ;
36905 PyObject * obj2 = 0 ;
36906 char *kwnames[] = {
36907 (char *) "self",(char *) "n",(char *) "clientData", NULL
36908 };
36909
36910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
36911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36912 if (SWIG_arg_fail(1)) SWIG_fail;
36913 {
36914 arg2 = (int)(SWIG_As_int(obj1));
36915 if (SWIG_arg_fail(2)) SWIG_fail;
36916 }
36917 arg3 = obj2;
36918 {
36919 PyThreadState* __tstate = wxPyBeginAllowThreads();
36920 wxItemContainer_SetClientData(arg1,arg2,arg3);
36921
36922 wxPyEndAllowThreads(__tstate);
36923 if (PyErr_Occurred()) SWIG_fail;
36924 }
36925 Py_INCREF(Py_None); resultobj = Py_None;
36926 return resultobj;
36927 fail:
36928 return NULL;
36929 }
36930
36931
36932 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
36933 PyObject *resultobj;
36934 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36935 int result;
36936 PyObject * obj0 = 0 ;
36937 char *kwnames[] = {
36938 (char *) "self", NULL
36939 };
36940
36941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
36942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36943 if (SWIG_arg_fail(1)) SWIG_fail;
36944 {
36945 PyThreadState* __tstate = wxPyBeginAllowThreads();
36946 result = (int)((wxItemContainer const *)arg1)->GetCount();
36947
36948 wxPyEndAllowThreads(__tstate);
36949 if (PyErr_Occurred()) SWIG_fail;
36950 }
36951 {
36952 resultobj = SWIG_From_int((int)(result));
36953 }
36954 return resultobj;
36955 fail:
36956 return NULL;
36957 }
36958
36959
36960 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
36961 PyObject *resultobj;
36962 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36963 bool result;
36964 PyObject * obj0 = 0 ;
36965 char *kwnames[] = {
36966 (char *) "self", NULL
36967 };
36968
36969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
36970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36971 if (SWIG_arg_fail(1)) SWIG_fail;
36972 {
36973 PyThreadState* __tstate = wxPyBeginAllowThreads();
36974 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
36975
36976 wxPyEndAllowThreads(__tstate);
36977 if (PyErr_Occurred()) SWIG_fail;
36978 }
36979 {
36980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36981 }
36982 return resultobj;
36983 fail:
36984 return NULL;
36985 }
36986
36987
36988 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
36989 PyObject *resultobj;
36990 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36991 int arg2 ;
36992 wxString result;
36993 PyObject * obj0 = 0 ;
36994 PyObject * obj1 = 0 ;
36995 char *kwnames[] = {
36996 (char *) "self",(char *) "n", NULL
36997 };
36998
36999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
37000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37001 if (SWIG_arg_fail(1)) SWIG_fail;
37002 {
37003 arg2 = (int)(SWIG_As_int(obj1));
37004 if (SWIG_arg_fail(2)) SWIG_fail;
37005 }
37006 {
37007 PyThreadState* __tstate = wxPyBeginAllowThreads();
37008 result = ((wxItemContainer const *)arg1)->GetString(arg2);
37009
37010 wxPyEndAllowThreads(__tstate);
37011 if (PyErr_Occurred()) SWIG_fail;
37012 }
37013 {
37014 #if wxUSE_UNICODE
37015 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37016 #else
37017 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37018 #endif
37019 }
37020 return resultobj;
37021 fail:
37022 return NULL;
37023 }
37024
37025
37026 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
37027 PyObject *resultobj;
37028 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37029 wxArrayString result;
37030 PyObject * obj0 = 0 ;
37031 char *kwnames[] = {
37032 (char *) "self", NULL
37033 };
37034
37035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
37036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37037 if (SWIG_arg_fail(1)) SWIG_fail;
37038 {
37039 PyThreadState* __tstate = wxPyBeginAllowThreads();
37040 result = ((wxItemContainer const *)arg1)->GetStrings();
37041
37042 wxPyEndAllowThreads(__tstate);
37043 if (PyErr_Occurred()) SWIG_fail;
37044 }
37045 {
37046 resultobj = wxArrayString2PyList_helper(result);
37047 }
37048 return resultobj;
37049 fail:
37050 return NULL;
37051 }
37052
37053
37054 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
37055 PyObject *resultobj;
37056 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37057 int arg2 ;
37058 wxString *arg3 = 0 ;
37059 bool temp3 = false ;
37060 PyObject * obj0 = 0 ;
37061 PyObject * obj1 = 0 ;
37062 PyObject * obj2 = 0 ;
37063 char *kwnames[] = {
37064 (char *) "self",(char *) "n",(char *) "s", NULL
37065 };
37066
37067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
37068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37069 if (SWIG_arg_fail(1)) SWIG_fail;
37070 {
37071 arg2 = (int)(SWIG_As_int(obj1));
37072 if (SWIG_arg_fail(2)) SWIG_fail;
37073 }
37074 {
37075 arg3 = wxString_in_helper(obj2);
37076 if (arg3 == NULL) SWIG_fail;
37077 temp3 = true;
37078 }
37079 {
37080 PyThreadState* __tstate = wxPyBeginAllowThreads();
37081 (arg1)->SetString(arg2,(wxString const &)*arg3);
37082
37083 wxPyEndAllowThreads(__tstate);
37084 if (PyErr_Occurred()) SWIG_fail;
37085 }
37086 Py_INCREF(Py_None); resultobj = Py_None;
37087 {
37088 if (temp3)
37089 delete arg3;
37090 }
37091 return resultobj;
37092 fail:
37093 {
37094 if (temp3)
37095 delete arg3;
37096 }
37097 return NULL;
37098 }
37099
37100
37101 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
37102 PyObject *resultobj;
37103 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37104 wxString *arg2 = 0 ;
37105 int result;
37106 bool temp2 = false ;
37107 PyObject * obj0 = 0 ;
37108 PyObject * obj1 = 0 ;
37109 char *kwnames[] = {
37110 (char *) "self",(char *) "s", NULL
37111 };
37112
37113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
37114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37115 if (SWIG_arg_fail(1)) SWIG_fail;
37116 {
37117 arg2 = wxString_in_helper(obj1);
37118 if (arg2 == NULL) SWIG_fail;
37119 temp2 = true;
37120 }
37121 {
37122 PyThreadState* __tstate = wxPyBeginAllowThreads();
37123 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
37124
37125 wxPyEndAllowThreads(__tstate);
37126 if (PyErr_Occurred()) SWIG_fail;
37127 }
37128 {
37129 resultobj = SWIG_From_int((int)(result));
37130 }
37131 {
37132 if (temp2)
37133 delete arg2;
37134 }
37135 return resultobj;
37136 fail:
37137 {
37138 if (temp2)
37139 delete arg2;
37140 }
37141 return NULL;
37142 }
37143
37144
37145 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37146 PyObject *resultobj;
37147 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37148 int arg2 ;
37149 PyObject * obj0 = 0 ;
37150 PyObject * obj1 = 0 ;
37151 char *kwnames[] = {
37152 (char *) "self",(char *) "n", NULL
37153 };
37154
37155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
37156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37157 if (SWIG_arg_fail(1)) SWIG_fail;
37158 {
37159 arg2 = (int)(SWIG_As_int(obj1));
37160 if (SWIG_arg_fail(2)) SWIG_fail;
37161 }
37162 {
37163 PyThreadState* __tstate = wxPyBeginAllowThreads();
37164 (arg1)->SetSelection(arg2);
37165
37166 wxPyEndAllowThreads(__tstate);
37167 if (PyErr_Occurred()) SWIG_fail;
37168 }
37169 Py_INCREF(Py_None); resultobj = Py_None;
37170 return resultobj;
37171 fail:
37172 return NULL;
37173 }
37174
37175
37176 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37177 PyObject *resultobj;
37178 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37179 int result;
37180 PyObject * obj0 = 0 ;
37181 char *kwnames[] = {
37182 (char *) "self", NULL
37183 };
37184
37185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
37186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37187 if (SWIG_arg_fail(1)) SWIG_fail;
37188 {
37189 PyThreadState* __tstate = wxPyBeginAllowThreads();
37190 result = (int)((wxItemContainer const *)arg1)->GetSelection();
37191
37192 wxPyEndAllowThreads(__tstate);
37193 if (PyErr_Occurred()) SWIG_fail;
37194 }
37195 {
37196 resultobj = SWIG_From_int((int)(result));
37197 }
37198 return resultobj;
37199 fail:
37200 return NULL;
37201 }
37202
37203
37204 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37205 PyObject *resultobj;
37206 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37207 wxString *arg2 = 0 ;
37208 bool result;
37209 bool temp2 = false ;
37210 PyObject * obj0 = 0 ;
37211 PyObject * obj1 = 0 ;
37212 char *kwnames[] = {
37213 (char *) "self",(char *) "s", NULL
37214 };
37215
37216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
37217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37218 if (SWIG_arg_fail(1)) SWIG_fail;
37219 {
37220 arg2 = wxString_in_helper(obj1);
37221 if (arg2 == NULL) SWIG_fail;
37222 temp2 = true;
37223 }
37224 {
37225 PyThreadState* __tstate = wxPyBeginAllowThreads();
37226 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
37227
37228 wxPyEndAllowThreads(__tstate);
37229 if (PyErr_Occurred()) SWIG_fail;
37230 }
37231 {
37232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37233 }
37234 {
37235 if (temp2)
37236 delete arg2;
37237 }
37238 return resultobj;
37239 fail:
37240 {
37241 if (temp2)
37242 delete arg2;
37243 }
37244 return NULL;
37245 }
37246
37247
37248 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37249 PyObject *resultobj;
37250 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37251 wxString result;
37252 PyObject * obj0 = 0 ;
37253 char *kwnames[] = {
37254 (char *) "self", NULL
37255 };
37256
37257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
37258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37259 if (SWIG_arg_fail(1)) SWIG_fail;
37260 {
37261 PyThreadState* __tstate = wxPyBeginAllowThreads();
37262 result = ((wxItemContainer const *)arg1)->GetStringSelection();
37263
37264 wxPyEndAllowThreads(__tstate);
37265 if (PyErr_Occurred()) SWIG_fail;
37266 }
37267 {
37268 #if wxUSE_UNICODE
37269 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37270 #else
37271 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37272 #endif
37273 }
37274 return resultobj;
37275 fail:
37276 return NULL;
37277 }
37278
37279
37280 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
37281 PyObject *resultobj;
37282 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37283 int arg2 ;
37284 PyObject * obj0 = 0 ;
37285 PyObject * obj1 = 0 ;
37286 char *kwnames[] = {
37287 (char *) "self",(char *) "n", NULL
37288 };
37289
37290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
37291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37292 if (SWIG_arg_fail(1)) SWIG_fail;
37293 {
37294 arg2 = (int)(SWIG_As_int(obj1));
37295 if (SWIG_arg_fail(2)) SWIG_fail;
37296 }
37297 {
37298 PyThreadState* __tstate = wxPyBeginAllowThreads();
37299 (arg1)->Select(arg2);
37300
37301 wxPyEndAllowThreads(__tstate);
37302 if (PyErr_Occurred()) SWIG_fail;
37303 }
37304 Py_INCREF(Py_None); resultobj = Py_None;
37305 return resultobj;
37306 fail:
37307 return NULL;
37308 }
37309
37310
37311 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
37312 PyObject *obj;
37313 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37314 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
37315 Py_INCREF(obj);
37316 return Py_BuildValue((char *)"");
37317 }
37318 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
37319 PyObject *obj;
37320 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37321 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
37322 Py_INCREF(obj);
37323 return Py_BuildValue((char *)"");
37324 }
37325 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
37326 PyObject *resultobj;
37327 wxSizerItem *result;
37328 char *kwnames[] = {
37329 NULL
37330 };
37331
37332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
37333 {
37334 PyThreadState* __tstate = wxPyBeginAllowThreads();
37335 result = (wxSizerItem *)new wxSizerItem();
37336
37337 wxPyEndAllowThreads(__tstate);
37338 if (PyErr_Occurred()) SWIG_fail;
37339 }
37340 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37341 return resultobj;
37342 fail:
37343 return NULL;
37344 }
37345
37346
37347 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37348 PyObject *resultobj;
37349 wxWindow *arg1 = (wxWindow *) 0 ;
37350 int arg2 ;
37351 int arg3 ;
37352 int arg4 ;
37353 PyObject *arg5 = (PyObject *) NULL ;
37354 wxSizerItem *result;
37355 PyObject * obj0 = 0 ;
37356 PyObject * obj1 = 0 ;
37357 PyObject * obj2 = 0 ;
37358 PyObject * obj3 = 0 ;
37359 PyObject * obj4 = 0 ;
37360 char *kwnames[] = {
37361 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37362 };
37363
37364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37366 if (SWIG_arg_fail(1)) SWIG_fail;
37367 {
37368 arg2 = (int)(SWIG_As_int(obj1));
37369 if (SWIG_arg_fail(2)) SWIG_fail;
37370 }
37371 {
37372 arg3 = (int)(SWIG_As_int(obj2));
37373 if (SWIG_arg_fail(3)) SWIG_fail;
37374 }
37375 {
37376 arg4 = (int)(SWIG_As_int(obj3));
37377 if (SWIG_arg_fail(4)) SWIG_fail;
37378 }
37379 if (obj4) {
37380 arg5 = obj4;
37381 }
37382 {
37383 PyThreadState* __tstate = wxPyBeginAllowThreads();
37384 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37385
37386 wxPyEndAllowThreads(__tstate);
37387 if (PyErr_Occurred()) SWIG_fail;
37388 }
37389 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37390 return resultobj;
37391 fail:
37392 return NULL;
37393 }
37394
37395
37396 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37397 PyObject *resultobj;
37398 int arg1 ;
37399 int arg2 ;
37400 int arg3 ;
37401 int arg4 ;
37402 int arg5 ;
37403 PyObject *arg6 = (PyObject *) NULL ;
37404 wxSizerItem *result;
37405 PyObject * obj0 = 0 ;
37406 PyObject * obj1 = 0 ;
37407 PyObject * obj2 = 0 ;
37408 PyObject * obj3 = 0 ;
37409 PyObject * obj4 = 0 ;
37410 PyObject * obj5 = 0 ;
37411 char *kwnames[] = {
37412 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37413 };
37414
37415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
37416 {
37417 arg1 = (int)(SWIG_As_int(obj0));
37418 if (SWIG_arg_fail(1)) SWIG_fail;
37419 }
37420 {
37421 arg2 = (int)(SWIG_As_int(obj1));
37422 if (SWIG_arg_fail(2)) SWIG_fail;
37423 }
37424 {
37425 arg3 = (int)(SWIG_As_int(obj2));
37426 if (SWIG_arg_fail(3)) SWIG_fail;
37427 }
37428 {
37429 arg4 = (int)(SWIG_As_int(obj3));
37430 if (SWIG_arg_fail(4)) SWIG_fail;
37431 }
37432 {
37433 arg5 = (int)(SWIG_As_int(obj4));
37434 if (SWIG_arg_fail(5)) SWIG_fail;
37435 }
37436 if (obj5) {
37437 arg6 = obj5;
37438 }
37439 {
37440 PyThreadState* __tstate = wxPyBeginAllowThreads();
37441 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
37442
37443 wxPyEndAllowThreads(__tstate);
37444 if (PyErr_Occurred()) SWIG_fail;
37445 }
37446 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37447 return resultobj;
37448 fail:
37449 return NULL;
37450 }
37451
37452
37453 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37454 PyObject *resultobj;
37455 wxSizer *arg1 = (wxSizer *) 0 ;
37456 int arg2 ;
37457 int arg3 ;
37458 int arg4 ;
37459 PyObject *arg5 = (PyObject *) NULL ;
37460 wxSizerItem *result;
37461 PyObject * obj0 = 0 ;
37462 PyObject * obj1 = 0 ;
37463 PyObject * obj2 = 0 ;
37464 PyObject * obj3 = 0 ;
37465 PyObject * obj4 = 0 ;
37466 char *kwnames[] = {
37467 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37468 };
37469
37470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
37472 if (SWIG_arg_fail(1)) SWIG_fail;
37473 {
37474 arg2 = (int)(SWIG_As_int(obj1));
37475 if (SWIG_arg_fail(2)) SWIG_fail;
37476 }
37477 {
37478 arg3 = (int)(SWIG_As_int(obj2));
37479 if (SWIG_arg_fail(3)) SWIG_fail;
37480 }
37481 {
37482 arg4 = (int)(SWIG_As_int(obj3));
37483 if (SWIG_arg_fail(4)) SWIG_fail;
37484 }
37485 if (obj4) {
37486 arg5 = obj4;
37487 }
37488 {
37489 PyThreadState* __tstate = wxPyBeginAllowThreads();
37490 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37491
37492 wxPyEndAllowThreads(__tstate);
37493 if (PyErr_Occurred()) SWIG_fail;
37494 }
37495 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37496 return resultobj;
37497 fail:
37498 return NULL;
37499 }
37500
37501
37502 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
37503 PyObject *resultobj;
37504 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37505 PyObject * obj0 = 0 ;
37506 char *kwnames[] = {
37507 (char *) "self", NULL
37508 };
37509
37510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
37511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37512 if (SWIG_arg_fail(1)) SWIG_fail;
37513 {
37514 PyThreadState* __tstate = wxPyBeginAllowThreads();
37515 (arg1)->DeleteWindows();
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_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37528 PyObject *resultobj;
37529 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37530 PyObject * obj0 = 0 ;
37531 char *kwnames[] = {
37532 (char *) "self", NULL
37533 };
37534
37535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
37536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37537 if (SWIG_arg_fail(1)) SWIG_fail;
37538 {
37539 PyThreadState* __tstate = wxPyBeginAllowThreads();
37540 (arg1)->DetachSizer();
37541
37542 wxPyEndAllowThreads(__tstate);
37543 if (PyErr_Occurred()) SWIG_fail;
37544 }
37545 Py_INCREF(Py_None); resultobj = Py_None;
37546 return resultobj;
37547 fail:
37548 return NULL;
37549 }
37550
37551
37552 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
37553 PyObject *resultobj;
37554 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37555 wxSize result;
37556 PyObject * obj0 = 0 ;
37557 char *kwnames[] = {
37558 (char *) "self", NULL
37559 };
37560
37561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
37562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37563 if (SWIG_arg_fail(1)) SWIG_fail;
37564 {
37565 PyThreadState* __tstate = wxPyBeginAllowThreads();
37566 result = (arg1)->GetSize();
37567
37568 wxPyEndAllowThreads(__tstate);
37569 if (PyErr_Occurred()) SWIG_fail;
37570 }
37571 {
37572 wxSize * resultptr;
37573 resultptr = new wxSize((wxSize &)(result));
37574 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37575 }
37576 return resultobj;
37577 fail:
37578 return NULL;
37579 }
37580
37581
37582 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
37583 PyObject *resultobj;
37584 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37585 wxSize result;
37586 PyObject * obj0 = 0 ;
37587 char *kwnames[] = {
37588 (char *) "self", NULL
37589 };
37590
37591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
37592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37593 if (SWIG_arg_fail(1)) SWIG_fail;
37594 {
37595 PyThreadState* __tstate = wxPyBeginAllowThreads();
37596 result = (arg1)->CalcMin();
37597
37598 wxPyEndAllowThreads(__tstate);
37599 if (PyErr_Occurred()) SWIG_fail;
37600 }
37601 {
37602 wxSize * resultptr;
37603 resultptr = new wxSize((wxSize &)(result));
37604 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37605 }
37606 return resultobj;
37607 fail:
37608 return NULL;
37609 }
37610
37611
37612 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
37613 PyObject *resultobj;
37614 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37615 wxPoint arg2 ;
37616 wxSize arg3 ;
37617 PyObject * obj0 = 0 ;
37618 PyObject * obj1 = 0 ;
37619 PyObject * obj2 = 0 ;
37620 char *kwnames[] = {
37621 (char *) "self",(char *) "pos",(char *) "size", NULL
37622 };
37623
37624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
37625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37626 if (SWIG_arg_fail(1)) SWIG_fail;
37627 {
37628 wxPoint * argp;
37629 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
37630 if (SWIG_arg_fail(2)) SWIG_fail;
37631 if (argp == NULL) {
37632 SWIG_null_ref("wxPoint");
37633 }
37634 if (SWIG_arg_fail(2)) SWIG_fail;
37635 arg2 = *argp;
37636 }
37637 {
37638 wxSize * argp;
37639 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
37640 if (SWIG_arg_fail(3)) SWIG_fail;
37641 if (argp == NULL) {
37642 SWIG_null_ref("wxSize");
37643 }
37644 if (SWIG_arg_fail(3)) SWIG_fail;
37645 arg3 = *argp;
37646 }
37647 {
37648 PyThreadState* __tstate = wxPyBeginAllowThreads();
37649 (arg1)->SetDimension(arg2,arg3);
37650
37651 wxPyEndAllowThreads(__tstate);
37652 if (PyErr_Occurred()) SWIG_fail;
37653 }
37654 Py_INCREF(Py_None); resultobj = Py_None;
37655 return resultobj;
37656 fail:
37657 return NULL;
37658 }
37659
37660
37661 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
37662 PyObject *resultobj;
37663 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37664 wxSize result;
37665 PyObject * obj0 = 0 ;
37666 char *kwnames[] = {
37667 (char *) "self", NULL
37668 };
37669
37670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
37671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37672 if (SWIG_arg_fail(1)) SWIG_fail;
37673 {
37674 PyThreadState* __tstate = wxPyBeginAllowThreads();
37675 result = (arg1)->GetMinSize();
37676
37677 wxPyEndAllowThreads(__tstate);
37678 if (PyErr_Occurred()) SWIG_fail;
37679 }
37680 {
37681 wxSize * resultptr;
37682 resultptr = new wxSize((wxSize &)(result));
37683 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37684 }
37685 return resultobj;
37686 fail:
37687 return NULL;
37688 }
37689
37690
37691 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37692 PyObject *resultobj;
37693 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37694 wxSize result;
37695 PyObject * obj0 = 0 ;
37696 char *kwnames[] = {
37697 (char *) "self", NULL
37698 };
37699
37700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
37701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37702 if (SWIG_arg_fail(1)) SWIG_fail;
37703 {
37704 PyThreadState* __tstate = wxPyBeginAllowThreads();
37705 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
37706
37707 wxPyEndAllowThreads(__tstate);
37708 if (PyErr_Occurred()) SWIG_fail;
37709 }
37710 {
37711 wxSize * resultptr;
37712 resultptr = new wxSize((wxSize &)(result));
37713 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37714 }
37715 return resultobj;
37716 fail:
37717 return NULL;
37718 }
37719
37720
37721 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
37722 PyObject *resultobj;
37723 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37724 int arg2 ;
37725 int arg3 ;
37726 PyObject * obj0 = 0 ;
37727 PyObject * obj1 = 0 ;
37728 PyObject * obj2 = 0 ;
37729 char *kwnames[] = {
37730 (char *) "self",(char *) "x",(char *) "y", NULL
37731 };
37732
37733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
37734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37735 if (SWIG_arg_fail(1)) SWIG_fail;
37736 {
37737 arg2 = (int)(SWIG_As_int(obj1));
37738 if (SWIG_arg_fail(2)) SWIG_fail;
37739 }
37740 {
37741 arg3 = (int)(SWIG_As_int(obj2));
37742 if (SWIG_arg_fail(3)) SWIG_fail;
37743 }
37744 {
37745 PyThreadState* __tstate = wxPyBeginAllowThreads();
37746 (arg1)->SetInitSize(arg2,arg3);
37747
37748 wxPyEndAllowThreads(__tstate);
37749 if (PyErr_Occurred()) SWIG_fail;
37750 }
37751 Py_INCREF(Py_None); resultobj = Py_None;
37752 return resultobj;
37753 fail:
37754 return NULL;
37755 }
37756
37757
37758 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
37759 PyObject *resultobj;
37760 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37761 int arg2 ;
37762 int arg3 ;
37763 PyObject * obj0 = 0 ;
37764 PyObject * obj1 = 0 ;
37765 PyObject * obj2 = 0 ;
37766 char *kwnames[] = {
37767 (char *) "self",(char *) "width",(char *) "height", NULL
37768 };
37769
37770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
37771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37772 if (SWIG_arg_fail(1)) SWIG_fail;
37773 {
37774 arg2 = (int)(SWIG_As_int(obj1));
37775 if (SWIG_arg_fail(2)) SWIG_fail;
37776 }
37777 {
37778 arg3 = (int)(SWIG_As_int(obj2));
37779 if (SWIG_arg_fail(3)) SWIG_fail;
37780 }
37781 {
37782 PyThreadState* __tstate = wxPyBeginAllowThreads();
37783 (arg1)->SetRatio(arg2,arg3);
37784
37785 wxPyEndAllowThreads(__tstate);
37786 if (PyErr_Occurred()) SWIG_fail;
37787 }
37788 Py_INCREF(Py_None); resultobj = Py_None;
37789 return resultobj;
37790 fail:
37791 return NULL;
37792 }
37793
37794
37795 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
37796 PyObject *resultobj;
37797 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37798 wxSize arg2 ;
37799 PyObject * obj0 = 0 ;
37800 PyObject * obj1 = 0 ;
37801 char *kwnames[] = {
37802 (char *) "self",(char *) "size", NULL
37803 };
37804
37805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
37806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37807 if (SWIG_arg_fail(1)) SWIG_fail;
37808 {
37809 wxSize * argp;
37810 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
37811 if (SWIG_arg_fail(2)) SWIG_fail;
37812 if (argp == NULL) {
37813 SWIG_null_ref("wxSize");
37814 }
37815 if (SWIG_arg_fail(2)) SWIG_fail;
37816 arg2 = *argp;
37817 }
37818 {
37819 PyThreadState* __tstate = wxPyBeginAllowThreads();
37820 (arg1)->SetRatio(arg2);
37821
37822 wxPyEndAllowThreads(__tstate);
37823 if (PyErr_Occurred()) SWIG_fail;
37824 }
37825 Py_INCREF(Py_None); resultobj = Py_None;
37826 return resultobj;
37827 fail:
37828 return NULL;
37829 }
37830
37831
37832 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
37833 PyObject *resultobj;
37834 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37835 float arg2 ;
37836 PyObject * obj0 = 0 ;
37837 PyObject * obj1 = 0 ;
37838 char *kwnames[] = {
37839 (char *) "self",(char *) "ratio", NULL
37840 };
37841
37842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
37843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37844 if (SWIG_arg_fail(1)) SWIG_fail;
37845 {
37846 arg2 = (float)(SWIG_As_float(obj1));
37847 if (SWIG_arg_fail(2)) SWIG_fail;
37848 }
37849 {
37850 PyThreadState* __tstate = wxPyBeginAllowThreads();
37851 (arg1)->SetRatio(arg2);
37852
37853 wxPyEndAllowThreads(__tstate);
37854 if (PyErr_Occurred()) SWIG_fail;
37855 }
37856 Py_INCREF(Py_None); resultobj = Py_None;
37857 return resultobj;
37858 fail:
37859 return NULL;
37860 }
37861
37862
37863 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
37864 PyObject *resultobj;
37865 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37866 float result;
37867 PyObject * obj0 = 0 ;
37868 char *kwnames[] = {
37869 (char *) "self", NULL
37870 };
37871
37872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
37873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37874 if (SWIG_arg_fail(1)) SWIG_fail;
37875 {
37876 PyThreadState* __tstate = wxPyBeginAllowThreads();
37877 result = (float)(arg1)->GetRatio();
37878
37879 wxPyEndAllowThreads(__tstate);
37880 if (PyErr_Occurred()) SWIG_fail;
37881 }
37882 {
37883 resultobj = SWIG_From_float((float)(result));
37884 }
37885 return resultobj;
37886 fail:
37887 return NULL;
37888 }
37889
37890
37891 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
37892 PyObject *resultobj;
37893 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37894 wxRect result;
37895 PyObject * obj0 = 0 ;
37896 char *kwnames[] = {
37897 (char *) "self", NULL
37898 };
37899
37900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
37901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37902 if (SWIG_arg_fail(1)) SWIG_fail;
37903 {
37904 PyThreadState* __tstate = wxPyBeginAllowThreads();
37905 result = (arg1)->GetRect();
37906
37907 wxPyEndAllowThreads(__tstate);
37908 if (PyErr_Occurred()) SWIG_fail;
37909 }
37910 {
37911 wxRect * resultptr;
37912 resultptr = new wxRect((wxRect &)(result));
37913 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
37914 }
37915 return resultobj;
37916 fail:
37917 return NULL;
37918 }
37919
37920
37921 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37922 PyObject *resultobj;
37923 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37924 bool result;
37925 PyObject * obj0 = 0 ;
37926 char *kwnames[] = {
37927 (char *) "self", NULL
37928 };
37929
37930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
37931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37932 if (SWIG_arg_fail(1)) SWIG_fail;
37933 {
37934 PyThreadState* __tstate = wxPyBeginAllowThreads();
37935 result = (bool)(arg1)->IsWindow();
37936
37937 wxPyEndAllowThreads(__tstate);
37938 if (PyErr_Occurred()) SWIG_fail;
37939 }
37940 {
37941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37942 }
37943 return resultobj;
37944 fail:
37945 return NULL;
37946 }
37947
37948
37949 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37950 PyObject *resultobj;
37951 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37952 bool result;
37953 PyObject * obj0 = 0 ;
37954 char *kwnames[] = {
37955 (char *) "self", NULL
37956 };
37957
37958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
37959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37960 if (SWIG_arg_fail(1)) SWIG_fail;
37961 {
37962 PyThreadState* __tstate = wxPyBeginAllowThreads();
37963 result = (bool)(arg1)->IsSizer();
37964
37965 wxPyEndAllowThreads(__tstate);
37966 if (PyErr_Occurred()) SWIG_fail;
37967 }
37968 {
37969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37970 }
37971 return resultobj;
37972 fail:
37973 return NULL;
37974 }
37975
37976
37977 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37978 PyObject *resultobj;
37979 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37980 bool result;
37981 PyObject * obj0 = 0 ;
37982 char *kwnames[] = {
37983 (char *) "self", NULL
37984 };
37985
37986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
37987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37988 if (SWIG_arg_fail(1)) SWIG_fail;
37989 {
37990 PyThreadState* __tstate = wxPyBeginAllowThreads();
37991 result = (bool)(arg1)->IsSpacer();
37992
37993 wxPyEndAllowThreads(__tstate);
37994 if (PyErr_Occurred()) SWIG_fail;
37995 }
37996 {
37997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37998 }
37999 return resultobj;
38000 fail:
38001 return NULL;
38002 }
38003
38004
38005 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38006 PyObject *resultobj;
38007 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38008 int arg2 ;
38009 PyObject * obj0 = 0 ;
38010 PyObject * obj1 = 0 ;
38011 char *kwnames[] = {
38012 (char *) "self",(char *) "proportion", NULL
38013 };
38014
38015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
38016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38017 if (SWIG_arg_fail(1)) SWIG_fail;
38018 {
38019 arg2 = (int)(SWIG_As_int(obj1));
38020 if (SWIG_arg_fail(2)) SWIG_fail;
38021 }
38022 {
38023 PyThreadState* __tstate = wxPyBeginAllowThreads();
38024 (arg1)->SetProportion(arg2);
38025
38026 wxPyEndAllowThreads(__tstate);
38027 if (PyErr_Occurred()) SWIG_fail;
38028 }
38029 Py_INCREF(Py_None); resultobj = Py_None;
38030 return resultobj;
38031 fail:
38032 return NULL;
38033 }
38034
38035
38036 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38037 PyObject *resultobj;
38038 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38039 int result;
38040 PyObject * obj0 = 0 ;
38041 char *kwnames[] = {
38042 (char *) "self", NULL
38043 };
38044
38045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
38046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38047 if (SWIG_arg_fail(1)) SWIG_fail;
38048 {
38049 PyThreadState* __tstate = wxPyBeginAllowThreads();
38050 result = (int)(arg1)->GetProportion();
38051
38052 wxPyEndAllowThreads(__tstate);
38053 if (PyErr_Occurred()) SWIG_fail;
38054 }
38055 {
38056 resultobj = SWIG_From_int((int)(result));
38057 }
38058 return resultobj;
38059 fail:
38060 return NULL;
38061 }
38062
38063
38064 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38065 PyObject *resultobj;
38066 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38067 int arg2 ;
38068 PyObject * obj0 = 0 ;
38069 PyObject * obj1 = 0 ;
38070 char *kwnames[] = {
38071 (char *) "self",(char *) "flag", NULL
38072 };
38073
38074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
38079 if (SWIG_arg_fail(2)) SWIG_fail;
38080 }
38081 {
38082 PyThreadState* __tstate = wxPyBeginAllowThreads();
38083 (arg1)->SetFlag(arg2);
38084
38085 wxPyEndAllowThreads(__tstate);
38086 if (PyErr_Occurred()) SWIG_fail;
38087 }
38088 Py_INCREF(Py_None); resultobj = Py_None;
38089 return resultobj;
38090 fail:
38091 return NULL;
38092 }
38093
38094
38095 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38096 PyObject *resultobj;
38097 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38098 int result;
38099 PyObject * obj0 = 0 ;
38100 char *kwnames[] = {
38101 (char *) "self", NULL
38102 };
38103
38104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
38105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38106 if (SWIG_arg_fail(1)) SWIG_fail;
38107 {
38108 PyThreadState* __tstate = wxPyBeginAllowThreads();
38109 result = (int)(arg1)->GetFlag();
38110
38111 wxPyEndAllowThreads(__tstate);
38112 if (PyErr_Occurred()) SWIG_fail;
38113 }
38114 {
38115 resultobj = SWIG_From_int((int)(result));
38116 }
38117 return resultobj;
38118 fail:
38119 return NULL;
38120 }
38121
38122
38123 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38124 PyObject *resultobj;
38125 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38126 int arg2 ;
38127 PyObject * obj0 = 0 ;
38128 PyObject * obj1 = 0 ;
38129 char *kwnames[] = {
38130 (char *) "self",(char *) "border", NULL
38131 };
38132
38133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
38134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38135 if (SWIG_arg_fail(1)) SWIG_fail;
38136 {
38137 arg2 = (int)(SWIG_As_int(obj1));
38138 if (SWIG_arg_fail(2)) SWIG_fail;
38139 }
38140 {
38141 PyThreadState* __tstate = wxPyBeginAllowThreads();
38142 (arg1)->SetBorder(arg2);
38143
38144 wxPyEndAllowThreads(__tstate);
38145 if (PyErr_Occurred()) SWIG_fail;
38146 }
38147 Py_INCREF(Py_None); resultobj = Py_None;
38148 return resultobj;
38149 fail:
38150 return NULL;
38151 }
38152
38153
38154 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38155 PyObject *resultobj;
38156 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38157 int result;
38158 PyObject * obj0 = 0 ;
38159 char *kwnames[] = {
38160 (char *) "self", NULL
38161 };
38162
38163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
38164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38165 if (SWIG_arg_fail(1)) SWIG_fail;
38166 {
38167 PyThreadState* __tstate = wxPyBeginAllowThreads();
38168 result = (int)(arg1)->GetBorder();
38169
38170 wxPyEndAllowThreads(__tstate);
38171 if (PyErr_Occurred()) SWIG_fail;
38172 }
38173 {
38174 resultobj = SWIG_From_int((int)(result));
38175 }
38176 return resultobj;
38177 fail:
38178 return NULL;
38179 }
38180
38181
38182 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38183 PyObject *resultobj;
38184 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38185 wxWindow *result;
38186 PyObject * obj0 = 0 ;
38187 char *kwnames[] = {
38188 (char *) "self", NULL
38189 };
38190
38191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
38192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38193 if (SWIG_arg_fail(1)) SWIG_fail;
38194 {
38195 PyThreadState* __tstate = wxPyBeginAllowThreads();
38196 result = (wxWindow *)(arg1)->GetWindow();
38197
38198 wxPyEndAllowThreads(__tstate);
38199 if (PyErr_Occurred()) SWIG_fail;
38200 }
38201 {
38202 resultobj = wxPyMake_wxObject(result, 0);
38203 }
38204 return resultobj;
38205 fail:
38206 return NULL;
38207 }
38208
38209
38210 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38211 PyObject *resultobj;
38212 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38213 wxWindow *arg2 = (wxWindow *) 0 ;
38214 PyObject * obj0 = 0 ;
38215 PyObject * obj1 = 0 ;
38216 char *kwnames[] = {
38217 (char *) "self",(char *) "window", NULL
38218 };
38219
38220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
38221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38222 if (SWIG_arg_fail(1)) SWIG_fail;
38223 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38224 if (SWIG_arg_fail(2)) SWIG_fail;
38225 {
38226 PyThreadState* __tstate = wxPyBeginAllowThreads();
38227 (arg1)->SetWindow(arg2);
38228
38229 wxPyEndAllowThreads(__tstate);
38230 if (PyErr_Occurred()) SWIG_fail;
38231 }
38232 Py_INCREF(Py_None); resultobj = Py_None;
38233 return resultobj;
38234 fail:
38235 return NULL;
38236 }
38237
38238
38239 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38240 PyObject *resultobj;
38241 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38242 wxSizer *result;
38243 PyObject * obj0 = 0 ;
38244 char *kwnames[] = {
38245 (char *) "self", NULL
38246 };
38247
38248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
38249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38250 if (SWIG_arg_fail(1)) SWIG_fail;
38251 {
38252 PyThreadState* __tstate = wxPyBeginAllowThreads();
38253 result = (wxSizer *)(arg1)->GetSizer();
38254
38255 wxPyEndAllowThreads(__tstate);
38256 if (PyErr_Occurred()) SWIG_fail;
38257 }
38258 {
38259 resultobj = wxPyMake_wxSizer(result, 0);
38260 }
38261 return resultobj;
38262 fail:
38263 return NULL;
38264 }
38265
38266
38267 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38268 PyObject *resultobj;
38269 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38270 wxSizer *arg2 = (wxSizer *) 0 ;
38271 PyObject * obj0 = 0 ;
38272 PyObject * obj1 = 0 ;
38273 char *kwnames[] = {
38274 (char *) "self",(char *) "sizer", NULL
38275 };
38276
38277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
38278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38279 if (SWIG_arg_fail(1)) SWIG_fail;
38280 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38281 if (SWIG_arg_fail(2)) SWIG_fail;
38282 {
38283 PyThreadState* __tstate = wxPyBeginAllowThreads();
38284 (arg1)->SetSizer(arg2);
38285
38286 wxPyEndAllowThreads(__tstate);
38287 if (PyErr_Occurred()) SWIG_fail;
38288 }
38289 Py_INCREF(Py_None); resultobj = Py_None;
38290 return resultobj;
38291 fail:
38292 return NULL;
38293 }
38294
38295
38296 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38297 PyObject *resultobj;
38298 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38299 wxSize *result;
38300 PyObject * obj0 = 0 ;
38301 char *kwnames[] = {
38302 (char *) "self", NULL
38303 };
38304
38305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
38306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38307 if (SWIG_arg_fail(1)) SWIG_fail;
38308 {
38309 PyThreadState* __tstate = wxPyBeginAllowThreads();
38310 {
38311 wxSize const &_result_ref = (arg1)->GetSpacer();
38312 result = (wxSize *) &_result_ref;
38313 }
38314
38315 wxPyEndAllowThreads(__tstate);
38316 if (PyErr_Occurred()) SWIG_fail;
38317 }
38318 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
38319 return resultobj;
38320 fail:
38321 return NULL;
38322 }
38323
38324
38325 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38326 PyObject *resultobj;
38327 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38328 wxSize *arg2 = 0 ;
38329 wxSize temp2 ;
38330 PyObject * obj0 = 0 ;
38331 PyObject * obj1 = 0 ;
38332 char *kwnames[] = {
38333 (char *) "self",(char *) "size", NULL
38334 };
38335
38336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
38337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38338 if (SWIG_arg_fail(1)) SWIG_fail;
38339 {
38340 arg2 = &temp2;
38341 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38342 }
38343 {
38344 PyThreadState* __tstate = wxPyBeginAllowThreads();
38345 (arg1)->SetSpacer((wxSize const &)*arg2);
38346
38347 wxPyEndAllowThreads(__tstate);
38348 if (PyErr_Occurred()) SWIG_fail;
38349 }
38350 Py_INCREF(Py_None); resultobj = Py_None;
38351 return resultobj;
38352 fail:
38353 return NULL;
38354 }
38355
38356
38357 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
38358 PyObject *resultobj;
38359 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38360 bool arg2 ;
38361 PyObject * obj0 = 0 ;
38362 PyObject * obj1 = 0 ;
38363 char *kwnames[] = {
38364 (char *) "self",(char *) "show", NULL
38365 };
38366
38367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
38368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38369 if (SWIG_arg_fail(1)) SWIG_fail;
38370 {
38371 arg2 = (bool)(SWIG_As_bool(obj1));
38372 if (SWIG_arg_fail(2)) SWIG_fail;
38373 }
38374 {
38375 PyThreadState* __tstate = wxPyBeginAllowThreads();
38376 (arg1)->Show(arg2);
38377
38378 wxPyEndAllowThreads(__tstate);
38379 if (PyErr_Occurred()) SWIG_fail;
38380 }
38381 Py_INCREF(Py_None); resultobj = Py_None;
38382 return resultobj;
38383 fail:
38384 return NULL;
38385 }
38386
38387
38388 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
38389 PyObject *resultobj;
38390 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38391 bool result;
38392 PyObject * obj0 = 0 ;
38393 char *kwnames[] = {
38394 (char *) "self", NULL
38395 };
38396
38397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
38398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38399 if (SWIG_arg_fail(1)) SWIG_fail;
38400 {
38401 PyThreadState* __tstate = wxPyBeginAllowThreads();
38402 result = (bool)(arg1)->IsShown();
38403
38404 wxPyEndAllowThreads(__tstate);
38405 if (PyErr_Occurred()) SWIG_fail;
38406 }
38407 {
38408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38409 }
38410 return resultobj;
38411 fail:
38412 return NULL;
38413 }
38414
38415
38416 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38417 PyObject *resultobj;
38418 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38419 wxPoint result;
38420 PyObject * obj0 = 0 ;
38421 char *kwnames[] = {
38422 (char *) "self", NULL
38423 };
38424
38425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
38426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38427 if (SWIG_arg_fail(1)) SWIG_fail;
38428 {
38429 PyThreadState* __tstate = wxPyBeginAllowThreads();
38430 result = (arg1)->GetPosition();
38431
38432 wxPyEndAllowThreads(__tstate);
38433 if (PyErr_Occurred()) SWIG_fail;
38434 }
38435 {
38436 wxPoint * resultptr;
38437 resultptr = new wxPoint((wxPoint &)(result));
38438 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38439 }
38440 return resultobj;
38441 fail:
38442 return NULL;
38443 }
38444
38445
38446 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
38447 PyObject *resultobj;
38448 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38449 PyObject *result;
38450 PyObject * obj0 = 0 ;
38451 char *kwnames[] = {
38452 (char *) "self", NULL
38453 };
38454
38455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
38456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38457 if (SWIG_arg_fail(1)) SWIG_fail;
38458 {
38459 PyThreadState* __tstate = wxPyBeginAllowThreads();
38460 result = (PyObject *)wxSizerItem_GetUserData(arg1);
38461
38462 wxPyEndAllowThreads(__tstate);
38463 if (PyErr_Occurred()) SWIG_fail;
38464 }
38465 resultobj = result;
38466 return resultobj;
38467 fail:
38468 return NULL;
38469 }
38470
38471
38472 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
38473 PyObject *obj;
38474 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38475 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
38476 Py_INCREF(obj);
38477 return Py_BuildValue((char *)"");
38478 }
38479 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
38480 PyObject *resultobj;
38481 wxSizer *arg1 = (wxSizer *) 0 ;
38482 PyObject *arg2 = (PyObject *) 0 ;
38483 PyObject * obj0 = 0 ;
38484 PyObject * obj1 = 0 ;
38485 char *kwnames[] = {
38486 (char *) "self",(char *) "_self", NULL
38487 };
38488
38489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
38490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38491 if (SWIG_arg_fail(1)) SWIG_fail;
38492 arg2 = obj1;
38493 {
38494 PyThreadState* __tstate = wxPyBeginAllowThreads();
38495 wxSizer__setOORInfo(arg1,arg2);
38496
38497 wxPyEndAllowThreads(__tstate);
38498 if (PyErr_Occurred()) SWIG_fail;
38499 }
38500 Py_INCREF(Py_None); resultobj = Py_None;
38501 return resultobj;
38502 fail:
38503 return NULL;
38504 }
38505
38506
38507 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
38508 PyObject *resultobj;
38509 wxSizer *arg1 = (wxSizer *) 0 ;
38510 PyObject *arg2 = (PyObject *) 0 ;
38511 int arg3 = (int) 0 ;
38512 int arg4 = (int) 0 ;
38513 int arg5 = (int) 0 ;
38514 PyObject *arg6 = (PyObject *) NULL ;
38515 wxSizerItem *result;
38516 PyObject * obj0 = 0 ;
38517 PyObject * obj1 = 0 ;
38518 PyObject * obj2 = 0 ;
38519 PyObject * obj3 = 0 ;
38520 PyObject * obj4 = 0 ;
38521 PyObject * obj5 = 0 ;
38522 char *kwnames[] = {
38523 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38524 };
38525
38526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38528 if (SWIG_arg_fail(1)) SWIG_fail;
38529 arg2 = obj1;
38530 if (obj2) {
38531 {
38532 arg3 = (int)(SWIG_As_int(obj2));
38533 if (SWIG_arg_fail(3)) SWIG_fail;
38534 }
38535 }
38536 if (obj3) {
38537 {
38538 arg4 = (int)(SWIG_As_int(obj3));
38539 if (SWIG_arg_fail(4)) SWIG_fail;
38540 }
38541 }
38542 if (obj4) {
38543 {
38544 arg5 = (int)(SWIG_As_int(obj4));
38545 if (SWIG_arg_fail(5)) SWIG_fail;
38546 }
38547 }
38548 if (obj5) {
38549 arg6 = obj5;
38550 }
38551 {
38552 PyThreadState* __tstate = wxPyBeginAllowThreads();
38553 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
38554
38555 wxPyEndAllowThreads(__tstate);
38556 if (PyErr_Occurred()) SWIG_fail;
38557 }
38558 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38559 return resultobj;
38560 fail:
38561 return NULL;
38562 }
38563
38564
38565 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38566 PyObject *resultobj;
38567 wxSizer *arg1 = (wxSizer *) 0 ;
38568 int arg2 ;
38569 PyObject *arg3 = (PyObject *) 0 ;
38570 int arg4 = (int) 0 ;
38571 int arg5 = (int) 0 ;
38572 int arg6 = (int) 0 ;
38573 PyObject *arg7 = (PyObject *) NULL ;
38574 wxSizerItem *result;
38575 PyObject * obj0 = 0 ;
38576 PyObject * obj1 = 0 ;
38577 PyObject * obj2 = 0 ;
38578 PyObject * obj3 = 0 ;
38579 PyObject * obj4 = 0 ;
38580 PyObject * obj5 = 0 ;
38581 PyObject * obj6 = 0 ;
38582 char *kwnames[] = {
38583 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38584 };
38585
38586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38588 if (SWIG_arg_fail(1)) SWIG_fail;
38589 {
38590 arg2 = (int)(SWIG_As_int(obj1));
38591 if (SWIG_arg_fail(2)) SWIG_fail;
38592 }
38593 arg3 = obj2;
38594 if (obj3) {
38595 {
38596 arg4 = (int)(SWIG_As_int(obj3));
38597 if (SWIG_arg_fail(4)) SWIG_fail;
38598 }
38599 }
38600 if (obj4) {
38601 {
38602 arg5 = (int)(SWIG_As_int(obj4));
38603 if (SWIG_arg_fail(5)) SWIG_fail;
38604 }
38605 }
38606 if (obj5) {
38607 {
38608 arg6 = (int)(SWIG_As_int(obj5));
38609 if (SWIG_arg_fail(6)) SWIG_fail;
38610 }
38611 }
38612 if (obj6) {
38613 arg7 = obj6;
38614 }
38615 {
38616 PyThreadState* __tstate = wxPyBeginAllowThreads();
38617 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
38618
38619 wxPyEndAllowThreads(__tstate);
38620 if (PyErr_Occurred()) SWIG_fail;
38621 }
38622 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38623 return resultobj;
38624 fail:
38625 return NULL;
38626 }
38627
38628
38629 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
38630 PyObject *resultobj;
38631 wxSizer *arg1 = (wxSizer *) 0 ;
38632 PyObject *arg2 = (PyObject *) 0 ;
38633 int arg3 = (int) 0 ;
38634 int arg4 = (int) 0 ;
38635 int arg5 = (int) 0 ;
38636 PyObject *arg6 = (PyObject *) NULL ;
38637 wxSizerItem *result;
38638 PyObject * obj0 = 0 ;
38639 PyObject * obj1 = 0 ;
38640 PyObject * obj2 = 0 ;
38641 PyObject * obj3 = 0 ;
38642 PyObject * obj4 = 0 ;
38643 PyObject * obj5 = 0 ;
38644 char *kwnames[] = {
38645 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38646 };
38647
38648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38650 if (SWIG_arg_fail(1)) SWIG_fail;
38651 arg2 = obj1;
38652 if (obj2) {
38653 {
38654 arg3 = (int)(SWIG_As_int(obj2));
38655 if (SWIG_arg_fail(3)) SWIG_fail;
38656 }
38657 }
38658 if (obj3) {
38659 {
38660 arg4 = (int)(SWIG_As_int(obj3));
38661 if (SWIG_arg_fail(4)) SWIG_fail;
38662 }
38663 }
38664 if (obj4) {
38665 {
38666 arg5 = (int)(SWIG_As_int(obj4));
38667 if (SWIG_arg_fail(5)) SWIG_fail;
38668 }
38669 }
38670 if (obj5) {
38671 arg6 = obj5;
38672 }
38673 {
38674 PyThreadState* __tstate = wxPyBeginAllowThreads();
38675 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
38676
38677 wxPyEndAllowThreads(__tstate);
38678 if (PyErr_Occurred()) SWIG_fail;
38679 }
38680 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38681 return resultobj;
38682 fail:
38683 return NULL;
38684 }
38685
38686
38687 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
38688 PyObject *resultobj;
38689 wxSizer *arg1 = (wxSizer *) 0 ;
38690 PyObject *arg2 = (PyObject *) 0 ;
38691 bool result;
38692 PyObject * obj0 = 0 ;
38693 PyObject * obj1 = 0 ;
38694 char *kwnames[] = {
38695 (char *) "self",(char *) "item", NULL
38696 };
38697
38698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
38699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38700 if (SWIG_arg_fail(1)) SWIG_fail;
38701 arg2 = obj1;
38702 {
38703 PyThreadState* __tstate = wxPyBeginAllowThreads();
38704 result = (bool)wxSizer_Remove(arg1,arg2);
38705
38706 wxPyEndAllowThreads(__tstate);
38707 if (PyErr_Occurred()) SWIG_fail;
38708 }
38709 {
38710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38711 }
38712 return resultobj;
38713 fail:
38714 return NULL;
38715 }
38716
38717
38718 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
38719 PyObject *resultobj;
38720 wxSizer *arg1 = (wxSizer *) 0 ;
38721 PyObject *arg2 = (PyObject *) 0 ;
38722 bool result;
38723 PyObject * obj0 = 0 ;
38724 PyObject * obj1 = 0 ;
38725 char *kwnames[] = {
38726 (char *) "self",(char *) "item", NULL
38727 };
38728
38729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
38730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38731 if (SWIG_arg_fail(1)) SWIG_fail;
38732 arg2 = obj1;
38733 {
38734 PyThreadState* __tstate = wxPyBeginAllowThreads();
38735 result = (bool)wxSizer_Detach(arg1,arg2);
38736
38737 wxPyEndAllowThreads(__tstate);
38738 if (PyErr_Occurred()) SWIG_fail;
38739 }
38740 {
38741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38742 }
38743 return resultobj;
38744 fail:
38745 return NULL;
38746 }
38747
38748
38749 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
38750 PyObject *resultobj;
38751 wxSizer *arg1 = (wxSizer *) 0 ;
38752 PyObject *arg2 = (PyObject *) 0 ;
38753 wxSizerItem *result;
38754 PyObject * obj0 = 0 ;
38755 PyObject * obj1 = 0 ;
38756 char *kwnames[] = {
38757 (char *) "self",(char *) "item", NULL
38758 };
38759
38760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
38761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38762 if (SWIG_arg_fail(1)) SWIG_fail;
38763 arg2 = obj1;
38764 {
38765 PyThreadState* __tstate = wxPyBeginAllowThreads();
38766 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
38767
38768 wxPyEndAllowThreads(__tstate);
38769 if (PyErr_Occurred()) SWIG_fail;
38770 }
38771 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38772 return resultobj;
38773 fail:
38774 return NULL;
38775 }
38776
38777
38778 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38779 PyObject *resultobj;
38780 wxSizer *arg1 = (wxSizer *) 0 ;
38781 PyObject *arg2 = (PyObject *) 0 ;
38782 wxSize *arg3 = 0 ;
38783 wxSize temp3 ;
38784 PyObject * obj0 = 0 ;
38785 PyObject * obj1 = 0 ;
38786 PyObject * obj2 = 0 ;
38787 char *kwnames[] = {
38788 (char *) "self",(char *) "item",(char *) "size", NULL
38789 };
38790
38791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38793 if (SWIG_arg_fail(1)) SWIG_fail;
38794 arg2 = obj1;
38795 {
38796 arg3 = &temp3;
38797 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
38798 }
38799 {
38800 PyThreadState* __tstate = wxPyBeginAllowThreads();
38801 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
38802
38803 wxPyEndAllowThreads(__tstate);
38804 if (PyErr_Occurred()) SWIG_fail;
38805 }
38806 Py_INCREF(Py_None); resultobj = Py_None;
38807 return resultobj;
38808 fail:
38809 return NULL;
38810 }
38811
38812
38813 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
38814 PyObject *resultobj;
38815 wxSizer *arg1 = (wxSizer *) 0 ;
38816 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
38817 wxSizerItem *result;
38818 PyObject * obj0 = 0 ;
38819 PyObject * obj1 = 0 ;
38820 char *kwnames[] = {
38821 (char *) "self",(char *) "item", NULL
38822 };
38823
38824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
38825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38826 if (SWIG_arg_fail(1)) SWIG_fail;
38827 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38828 if (SWIG_arg_fail(2)) SWIG_fail;
38829 {
38830 PyThreadState* __tstate = wxPyBeginAllowThreads();
38831 result = (wxSizerItem *)(arg1)->Add(arg2);
38832
38833 wxPyEndAllowThreads(__tstate);
38834 if (PyErr_Occurred()) SWIG_fail;
38835 }
38836 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38837 return resultobj;
38838 fail:
38839 return NULL;
38840 }
38841
38842
38843 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
38844 PyObject *resultobj;
38845 wxSizer *arg1 = (wxSizer *) 0 ;
38846 size_t arg2 ;
38847 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
38848 wxSizerItem *result;
38849 PyObject * obj0 = 0 ;
38850 PyObject * obj1 = 0 ;
38851 PyObject * obj2 = 0 ;
38852 char *kwnames[] = {
38853 (char *) "self",(char *) "index",(char *) "item", NULL
38854 };
38855
38856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
38857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38858 if (SWIG_arg_fail(1)) SWIG_fail;
38859 {
38860 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
38861 if (SWIG_arg_fail(2)) SWIG_fail;
38862 }
38863 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38864 if (SWIG_arg_fail(3)) SWIG_fail;
38865 {
38866 PyThreadState* __tstate = wxPyBeginAllowThreads();
38867 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
38868
38869 wxPyEndAllowThreads(__tstate);
38870 if (PyErr_Occurred()) SWIG_fail;
38871 }
38872 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38873 return resultobj;
38874 fail:
38875 return NULL;
38876 }
38877
38878
38879 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
38880 PyObject *resultobj;
38881 wxSizer *arg1 = (wxSizer *) 0 ;
38882 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
38883 wxSizerItem *result;
38884 PyObject * obj0 = 0 ;
38885 PyObject * obj1 = 0 ;
38886 char *kwnames[] = {
38887 (char *) "self",(char *) "item", NULL
38888 };
38889
38890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
38891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38892 if (SWIG_arg_fail(1)) SWIG_fail;
38893 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38894 if (SWIG_arg_fail(2)) SWIG_fail;
38895 {
38896 PyThreadState* __tstate = wxPyBeginAllowThreads();
38897 result = (wxSizerItem *)(arg1)->Prepend(arg2);
38898
38899 wxPyEndAllowThreads(__tstate);
38900 if (PyErr_Occurred()) SWIG_fail;
38901 }
38902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38903 return resultobj;
38904 fail:
38905 return NULL;
38906 }
38907
38908
38909 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38910 PyObject *resultobj;
38911 wxSizer *arg1 = (wxSizer *) 0 ;
38912 int arg2 ;
38913 int arg3 ;
38914 int arg4 ;
38915 int arg5 ;
38916 PyObject * obj0 = 0 ;
38917 PyObject * obj1 = 0 ;
38918 PyObject * obj2 = 0 ;
38919 PyObject * obj3 = 0 ;
38920 PyObject * obj4 = 0 ;
38921 char *kwnames[] = {
38922 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
38923 };
38924
38925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38927 if (SWIG_arg_fail(1)) SWIG_fail;
38928 {
38929 arg2 = (int)(SWIG_As_int(obj1));
38930 if (SWIG_arg_fail(2)) SWIG_fail;
38931 }
38932 {
38933 arg3 = (int)(SWIG_As_int(obj2));
38934 if (SWIG_arg_fail(3)) SWIG_fail;
38935 }
38936 {
38937 arg4 = (int)(SWIG_As_int(obj3));
38938 if (SWIG_arg_fail(4)) SWIG_fail;
38939 }
38940 {
38941 arg5 = (int)(SWIG_As_int(obj4));
38942 if (SWIG_arg_fail(5)) SWIG_fail;
38943 }
38944 {
38945 PyThreadState* __tstate = wxPyBeginAllowThreads();
38946 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
38947
38948 wxPyEndAllowThreads(__tstate);
38949 if (PyErr_Occurred()) SWIG_fail;
38950 }
38951 Py_INCREF(Py_None); resultobj = Py_None;
38952 return resultobj;
38953 fail:
38954 return NULL;
38955 }
38956
38957
38958 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38959 PyObject *resultobj;
38960 wxSizer *arg1 = (wxSizer *) 0 ;
38961 wxSize *arg2 = 0 ;
38962 wxSize temp2 ;
38963 PyObject * obj0 = 0 ;
38964 PyObject * obj1 = 0 ;
38965 char *kwnames[] = {
38966 (char *) "self",(char *) "size", NULL
38967 };
38968
38969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
38970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38971 if (SWIG_arg_fail(1)) SWIG_fail;
38972 {
38973 arg2 = &temp2;
38974 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38975 }
38976 {
38977 PyThreadState* __tstate = wxPyBeginAllowThreads();
38978 (arg1)->SetMinSize((wxSize const &)*arg2);
38979
38980 wxPyEndAllowThreads(__tstate);
38981 if (PyErr_Occurred()) SWIG_fail;
38982 }
38983 Py_INCREF(Py_None); resultobj = Py_None;
38984 return resultobj;
38985 fail:
38986 return NULL;
38987 }
38988
38989
38990 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38991 PyObject *resultobj;
38992 wxSizer *arg1 = (wxSizer *) 0 ;
38993 wxSize result;
38994 PyObject * obj0 = 0 ;
38995 char *kwnames[] = {
38996 (char *) "self", NULL
38997 };
38998
38999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
39000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39001 if (SWIG_arg_fail(1)) SWIG_fail;
39002 {
39003 PyThreadState* __tstate = wxPyBeginAllowThreads();
39004 result = (arg1)->GetSize();
39005
39006 wxPyEndAllowThreads(__tstate);
39007 if (PyErr_Occurred()) SWIG_fail;
39008 }
39009 {
39010 wxSize * resultptr;
39011 resultptr = new wxSize((wxSize &)(result));
39012 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39013 }
39014 return resultobj;
39015 fail:
39016 return NULL;
39017 }
39018
39019
39020 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39021 PyObject *resultobj;
39022 wxSizer *arg1 = (wxSizer *) 0 ;
39023 wxPoint result;
39024 PyObject * obj0 = 0 ;
39025 char *kwnames[] = {
39026 (char *) "self", NULL
39027 };
39028
39029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
39030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39031 if (SWIG_arg_fail(1)) SWIG_fail;
39032 {
39033 PyThreadState* __tstate = wxPyBeginAllowThreads();
39034 result = (arg1)->GetPosition();
39035
39036 wxPyEndAllowThreads(__tstate);
39037 if (PyErr_Occurred()) SWIG_fail;
39038 }
39039 {
39040 wxPoint * resultptr;
39041 resultptr = new wxPoint((wxPoint &)(result));
39042 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39043 }
39044 return resultobj;
39045 fail:
39046 return NULL;
39047 }
39048
39049
39050 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39051 PyObject *resultobj;
39052 wxSizer *arg1 = (wxSizer *) 0 ;
39053 wxSize result;
39054 PyObject * obj0 = 0 ;
39055 char *kwnames[] = {
39056 (char *) "self", NULL
39057 };
39058
39059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
39060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39061 if (SWIG_arg_fail(1)) SWIG_fail;
39062 {
39063 PyThreadState* __tstate = wxPyBeginAllowThreads();
39064 result = (arg1)->GetMinSize();
39065
39066 wxPyEndAllowThreads(__tstate);
39067 if (PyErr_Occurred()) SWIG_fail;
39068 }
39069 {
39070 wxSize * resultptr;
39071 resultptr = new wxSize((wxSize &)(result));
39072 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39073 }
39074 return resultobj;
39075 fail:
39076 return NULL;
39077 }
39078
39079
39080 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
39081 PyObject *resultobj;
39082 wxSizer *arg1 = (wxSizer *) 0 ;
39083 PyObject * obj0 = 0 ;
39084 char *kwnames[] = {
39085 (char *) "self", NULL
39086 };
39087
39088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
39089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39090 if (SWIG_arg_fail(1)) SWIG_fail;
39091 {
39092 PyThreadState* __tstate = wxPyBeginAllowThreads();
39093 (arg1)->RecalcSizes();
39094
39095 wxPyEndAllowThreads(__tstate);
39096 if (PyErr_Occurred()) SWIG_fail;
39097 }
39098 Py_INCREF(Py_None); resultobj = Py_None;
39099 return resultobj;
39100 fail:
39101 return NULL;
39102 }
39103
39104
39105 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39106 PyObject *resultobj;
39107 wxSizer *arg1 = (wxSizer *) 0 ;
39108 wxSize result;
39109 PyObject * obj0 = 0 ;
39110 char *kwnames[] = {
39111 (char *) "self", NULL
39112 };
39113
39114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
39115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39116 if (SWIG_arg_fail(1)) SWIG_fail;
39117 {
39118 PyThreadState* __tstate = wxPyBeginAllowThreads();
39119 result = (arg1)->CalcMin();
39120
39121 wxPyEndAllowThreads(__tstate);
39122 if (PyErr_Occurred()) SWIG_fail;
39123 }
39124 {
39125 wxSize * resultptr;
39126 resultptr = new wxSize((wxSize &)(result));
39127 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39128 }
39129 return resultobj;
39130 fail:
39131 return NULL;
39132 }
39133
39134
39135 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
39136 PyObject *resultobj;
39137 wxSizer *arg1 = (wxSizer *) 0 ;
39138 PyObject * obj0 = 0 ;
39139 char *kwnames[] = {
39140 (char *) "self", NULL
39141 };
39142
39143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
39144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39145 if (SWIG_arg_fail(1)) SWIG_fail;
39146 {
39147 PyThreadState* __tstate = wxPyBeginAllowThreads();
39148 (arg1)->Layout();
39149
39150 wxPyEndAllowThreads(__tstate);
39151 if (PyErr_Occurred()) SWIG_fail;
39152 }
39153 Py_INCREF(Py_None); resultobj = Py_None;
39154 return resultobj;
39155 fail:
39156 return NULL;
39157 }
39158
39159
39160 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
39161 PyObject *resultobj;
39162 wxSizer *arg1 = (wxSizer *) 0 ;
39163 wxWindow *arg2 = (wxWindow *) 0 ;
39164 wxSize result;
39165 PyObject * obj0 = 0 ;
39166 PyObject * obj1 = 0 ;
39167 char *kwnames[] = {
39168 (char *) "self",(char *) "window", NULL
39169 };
39170
39171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
39172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39173 if (SWIG_arg_fail(1)) SWIG_fail;
39174 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39175 if (SWIG_arg_fail(2)) SWIG_fail;
39176 {
39177 PyThreadState* __tstate = wxPyBeginAllowThreads();
39178 result = (arg1)->Fit(arg2);
39179
39180 wxPyEndAllowThreads(__tstate);
39181 if (PyErr_Occurred()) SWIG_fail;
39182 }
39183 {
39184 wxSize * resultptr;
39185 resultptr = new wxSize((wxSize &)(result));
39186 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39187 }
39188 return resultobj;
39189 fail:
39190 return NULL;
39191 }
39192
39193
39194 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
39195 PyObject *resultobj;
39196 wxSizer *arg1 = (wxSizer *) 0 ;
39197 wxWindow *arg2 = (wxWindow *) 0 ;
39198 PyObject * obj0 = 0 ;
39199 PyObject * obj1 = 0 ;
39200 char *kwnames[] = {
39201 (char *) "self",(char *) "window", NULL
39202 };
39203
39204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
39205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39206 if (SWIG_arg_fail(1)) SWIG_fail;
39207 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39208 if (SWIG_arg_fail(2)) SWIG_fail;
39209 {
39210 PyThreadState* __tstate = wxPyBeginAllowThreads();
39211 (arg1)->FitInside(arg2);
39212
39213 wxPyEndAllowThreads(__tstate);
39214 if (PyErr_Occurred()) SWIG_fail;
39215 }
39216 Py_INCREF(Py_None); resultobj = Py_None;
39217 return resultobj;
39218 fail:
39219 return NULL;
39220 }
39221
39222
39223 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39224 PyObject *resultobj;
39225 wxSizer *arg1 = (wxSizer *) 0 ;
39226 wxWindow *arg2 = (wxWindow *) 0 ;
39227 PyObject * obj0 = 0 ;
39228 PyObject * obj1 = 0 ;
39229 char *kwnames[] = {
39230 (char *) "self",(char *) "window", NULL
39231 };
39232
39233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
39234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39235 if (SWIG_arg_fail(1)) SWIG_fail;
39236 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39237 if (SWIG_arg_fail(2)) SWIG_fail;
39238 {
39239 PyThreadState* __tstate = wxPyBeginAllowThreads();
39240 (arg1)->SetSizeHints(arg2);
39241
39242 wxPyEndAllowThreads(__tstate);
39243 if (PyErr_Occurred()) SWIG_fail;
39244 }
39245 Py_INCREF(Py_None); resultobj = Py_None;
39246 return resultobj;
39247 fail:
39248 return NULL;
39249 }
39250
39251
39252 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39253 PyObject *resultobj;
39254 wxSizer *arg1 = (wxSizer *) 0 ;
39255 wxWindow *arg2 = (wxWindow *) 0 ;
39256 PyObject * obj0 = 0 ;
39257 PyObject * obj1 = 0 ;
39258 char *kwnames[] = {
39259 (char *) "self",(char *) "window", NULL
39260 };
39261
39262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
39263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39264 if (SWIG_arg_fail(1)) SWIG_fail;
39265 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39266 if (SWIG_arg_fail(2)) SWIG_fail;
39267 {
39268 PyThreadState* __tstate = wxPyBeginAllowThreads();
39269 (arg1)->SetVirtualSizeHints(arg2);
39270
39271 wxPyEndAllowThreads(__tstate);
39272 if (PyErr_Occurred()) SWIG_fail;
39273 }
39274 Py_INCREF(Py_None); resultobj = Py_None;
39275 return resultobj;
39276 fail:
39277 return NULL;
39278 }
39279
39280
39281 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
39282 PyObject *resultobj;
39283 wxSizer *arg1 = (wxSizer *) 0 ;
39284 bool arg2 = (bool) false ;
39285 PyObject * obj0 = 0 ;
39286 PyObject * obj1 = 0 ;
39287 char *kwnames[] = {
39288 (char *) "self",(char *) "deleteWindows", NULL
39289 };
39290
39291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
39292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39293 if (SWIG_arg_fail(1)) SWIG_fail;
39294 if (obj1) {
39295 {
39296 arg2 = (bool)(SWIG_As_bool(obj1));
39297 if (SWIG_arg_fail(2)) SWIG_fail;
39298 }
39299 }
39300 {
39301 PyThreadState* __tstate = wxPyBeginAllowThreads();
39302 (arg1)->Clear(arg2);
39303
39304 wxPyEndAllowThreads(__tstate);
39305 if (PyErr_Occurred()) SWIG_fail;
39306 }
39307 Py_INCREF(Py_None); resultobj = Py_None;
39308 return resultobj;
39309 fail:
39310 return NULL;
39311 }
39312
39313
39314 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39315 PyObject *resultobj;
39316 wxSizer *arg1 = (wxSizer *) 0 ;
39317 PyObject * obj0 = 0 ;
39318 char *kwnames[] = {
39319 (char *) "self", NULL
39320 };
39321
39322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
39323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39324 if (SWIG_arg_fail(1)) SWIG_fail;
39325 {
39326 PyThreadState* __tstate = wxPyBeginAllowThreads();
39327 (arg1)->DeleteWindows();
39328
39329 wxPyEndAllowThreads(__tstate);
39330 if (PyErr_Occurred()) SWIG_fail;
39331 }
39332 Py_INCREF(Py_None); resultobj = Py_None;
39333 return resultobj;
39334 fail:
39335 return NULL;
39336 }
39337
39338
39339 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
39340 PyObject *resultobj;
39341 wxSizer *arg1 = (wxSizer *) 0 ;
39342 PyObject *result;
39343 PyObject * obj0 = 0 ;
39344 char *kwnames[] = {
39345 (char *) "self", NULL
39346 };
39347
39348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
39349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39350 if (SWIG_arg_fail(1)) SWIG_fail;
39351 {
39352 PyThreadState* __tstate = wxPyBeginAllowThreads();
39353 result = (PyObject *)wxSizer_GetChildren(arg1);
39354
39355 wxPyEndAllowThreads(__tstate);
39356 if (PyErr_Occurred()) SWIG_fail;
39357 }
39358 resultobj = result;
39359 return resultobj;
39360 fail:
39361 return NULL;
39362 }
39363
39364
39365 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39366 PyObject *resultobj;
39367 wxSizer *arg1 = (wxSizer *) 0 ;
39368 PyObject *arg2 = (PyObject *) 0 ;
39369 bool arg3 = (bool) true ;
39370 bool arg4 = (bool) false ;
39371 bool result;
39372 PyObject * obj0 = 0 ;
39373 PyObject * obj1 = 0 ;
39374 PyObject * obj2 = 0 ;
39375 PyObject * obj3 = 0 ;
39376 char *kwnames[] = {
39377 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
39378 };
39379
39380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39382 if (SWIG_arg_fail(1)) SWIG_fail;
39383 arg2 = obj1;
39384 if (obj2) {
39385 {
39386 arg3 = (bool)(SWIG_As_bool(obj2));
39387 if (SWIG_arg_fail(3)) SWIG_fail;
39388 }
39389 }
39390 if (obj3) {
39391 {
39392 arg4 = (bool)(SWIG_As_bool(obj3));
39393 if (SWIG_arg_fail(4)) SWIG_fail;
39394 }
39395 }
39396 {
39397 PyThreadState* __tstate = wxPyBeginAllowThreads();
39398 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
39399
39400 wxPyEndAllowThreads(__tstate);
39401 if (PyErr_Occurred()) SWIG_fail;
39402 }
39403 {
39404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39405 }
39406 return resultobj;
39407 fail:
39408 return NULL;
39409 }
39410
39411
39412 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39413 PyObject *resultobj;
39414 wxSizer *arg1 = (wxSizer *) 0 ;
39415 PyObject *arg2 = (PyObject *) 0 ;
39416 bool result;
39417 PyObject * obj0 = 0 ;
39418 PyObject * obj1 = 0 ;
39419 char *kwnames[] = {
39420 (char *) "self",(char *) "item", NULL
39421 };
39422
39423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
39424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39425 if (SWIG_arg_fail(1)) SWIG_fail;
39426 arg2 = obj1;
39427 {
39428 PyThreadState* __tstate = wxPyBeginAllowThreads();
39429 result = (bool)wxSizer_IsShown(arg1,arg2);
39430
39431 wxPyEndAllowThreads(__tstate);
39432 if (PyErr_Occurred()) SWIG_fail;
39433 }
39434 {
39435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39436 }
39437 return resultobj;
39438 fail:
39439 return NULL;
39440 }
39441
39442
39443 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
39444 PyObject *resultobj;
39445 wxSizer *arg1 = (wxSizer *) 0 ;
39446 bool arg2 ;
39447 PyObject * obj0 = 0 ;
39448 PyObject * obj1 = 0 ;
39449 char *kwnames[] = {
39450 (char *) "self",(char *) "show", NULL
39451 };
39452
39453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
39454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39455 if (SWIG_arg_fail(1)) SWIG_fail;
39456 {
39457 arg2 = (bool)(SWIG_As_bool(obj1));
39458 if (SWIG_arg_fail(2)) SWIG_fail;
39459 }
39460 {
39461 PyThreadState* __tstate = wxPyBeginAllowThreads();
39462 (arg1)->ShowItems(arg2);
39463
39464 wxPyEndAllowThreads(__tstate);
39465 if (PyErr_Occurred()) SWIG_fail;
39466 }
39467 Py_INCREF(Py_None); resultobj = Py_None;
39468 return resultobj;
39469 fail:
39470 return NULL;
39471 }
39472
39473
39474 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
39475 PyObject *obj;
39476 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39477 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
39478 Py_INCREF(obj);
39479 return Py_BuildValue((char *)"");
39480 }
39481 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
39482 PyObject *resultobj;
39483 wxPySizer *result;
39484 char *kwnames[] = {
39485 NULL
39486 };
39487
39488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
39489 {
39490 PyThreadState* __tstate = wxPyBeginAllowThreads();
39491 result = (wxPySizer *)new wxPySizer();
39492
39493 wxPyEndAllowThreads(__tstate);
39494 if (PyErr_Occurred()) SWIG_fail;
39495 }
39496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
39497 return resultobj;
39498 fail:
39499 return NULL;
39500 }
39501
39502
39503 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39504 PyObject *resultobj;
39505 wxPySizer *arg1 = (wxPySizer *) 0 ;
39506 PyObject *arg2 = (PyObject *) 0 ;
39507 PyObject *arg3 = (PyObject *) 0 ;
39508 PyObject * obj0 = 0 ;
39509 PyObject * obj1 = 0 ;
39510 PyObject * obj2 = 0 ;
39511 char *kwnames[] = {
39512 (char *) "self",(char *) "self",(char *) "_class", NULL
39513 };
39514
39515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
39516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
39517 if (SWIG_arg_fail(1)) SWIG_fail;
39518 arg2 = obj1;
39519 arg3 = obj2;
39520 {
39521 PyThreadState* __tstate = wxPyBeginAllowThreads();
39522 (arg1)->_setCallbackInfo(arg2,arg3);
39523
39524 wxPyEndAllowThreads(__tstate);
39525 if (PyErr_Occurred()) SWIG_fail;
39526 }
39527 Py_INCREF(Py_None); resultobj = Py_None;
39528 return resultobj;
39529 fail:
39530 return NULL;
39531 }
39532
39533
39534 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
39535 PyObject *obj;
39536 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39537 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
39538 Py_INCREF(obj);
39539 return Py_BuildValue((char *)"");
39540 }
39541 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39542 PyObject *resultobj;
39543 int arg1 = (int) wxHORIZONTAL ;
39544 wxBoxSizer *result;
39545 PyObject * obj0 = 0 ;
39546 char *kwnames[] = {
39547 (char *) "orient", NULL
39548 };
39549
39550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
39551 if (obj0) {
39552 {
39553 arg1 = (int)(SWIG_As_int(obj0));
39554 if (SWIG_arg_fail(1)) SWIG_fail;
39555 }
39556 }
39557 {
39558 PyThreadState* __tstate = wxPyBeginAllowThreads();
39559 result = (wxBoxSizer *)new wxBoxSizer(arg1);
39560
39561 wxPyEndAllowThreads(__tstate);
39562 if (PyErr_Occurred()) SWIG_fail;
39563 }
39564 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
39565 return resultobj;
39566 fail:
39567 return NULL;
39568 }
39569
39570
39571 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
39572 PyObject *resultobj;
39573 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
39574 int result;
39575 PyObject * obj0 = 0 ;
39576 char *kwnames[] = {
39577 (char *) "self", NULL
39578 };
39579
39580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
39581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39582 if (SWIG_arg_fail(1)) SWIG_fail;
39583 {
39584 PyThreadState* __tstate = wxPyBeginAllowThreads();
39585 result = (int)(arg1)->GetOrientation();
39586
39587 wxPyEndAllowThreads(__tstate);
39588 if (PyErr_Occurred()) SWIG_fail;
39589 }
39590 {
39591 resultobj = SWIG_From_int((int)(result));
39592 }
39593 return resultobj;
39594 fail:
39595 return NULL;
39596 }
39597
39598
39599 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
39600 PyObject *resultobj;
39601 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
39602 int arg2 ;
39603 PyObject * obj0 = 0 ;
39604 PyObject * obj1 = 0 ;
39605 char *kwnames[] = {
39606 (char *) "self",(char *) "orient", NULL
39607 };
39608
39609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
39610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39611 if (SWIG_arg_fail(1)) SWIG_fail;
39612 {
39613 arg2 = (int)(SWIG_As_int(obj1));
39614 if (SWIG_arg_fail(2)) SWIG_fail;
39615 }
39616 {
39617 PyThreadState* __tstate = wxPyBeginAllowThreads();
39618 (arg1)->SetOrientation(arg2);
39619
39620 wxPyEndAllowThreads(__tstate);
39621 if (PyErr_Occurred()) SWIG_fail;
39622 }
39623 Py_INCREF(Py_None); resultobj = Py_None;
39624 return resultobj;
39625 fail:
39626 return NULL;
39627 }
39628
39629
39630 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
39631 PyObject *obj;
39632 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39633 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
39634 Py_INCREF(obj);
39635 return Py_BuildValue((char *)"");
39636 }
39637 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39638 PyObject *resultobj;
39639 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
39640 int arg2 = (int) wxHORIZONTAL ;
39641 wxStaticBoxSizer *result;
39642 PyObject * obj0 = 0 ;
39643 PyObject * obj1 = 0 ;
39644 char *kwnames[] = {
39645 (char *) "box",(char *) "orient", NULL
39646 };
39647
39648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
39649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
39650 if (SWIG_arg_fail(1)) SWIG_fail;
39651 if (obj1) {
39652 {
39653 arg2 = (int)(SWIG_As_int(obj1));
39654 if (SWIG_arg_fail(2)) SWIG_fail;
39655 }
39656 }
39657 {
39658 PyThreadState* __tstate = wxPyBeginAllowThreads();
39659 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
39660
39661 wxPyEndAllowThreads(__tstate);
39662 if (PyErr_Occurred()) SWIG_fail;
39663 }
39664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
39665 return resultobj;
39666 fail:
39667 return NULL;
39668 }
39669
39670
39671 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
39672 PyObject *resultobj;
39673 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
39674 wxStaticBox *result;
39675 PyObject * obj0 = 0 ;
39676 char *kwnames[] = {
39677 (char *) "self", NULL
39678 };
39679
39680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
39681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39682 if (SWIG_arg_fail(1)) SWIG_fail;
39683 {
39684 PyThreadState* __tstate = wxPyBeginAllowThreads();
39685 result = (wxStaticBox *)(arg1)->GetStaticBox();
39686
39687 wxPyEndAllowThreads(__tstate);
39688 if (PyErr_Occurred()) SWIG_fail;
39689 }
39690 {
39691 resultobj = wxPyMake_wxObject(result, 0);
39692 }
39693 return resultobj;
39694 fail:
39695 return NULL;
39696 }
39697
39698
39699 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
39700 PyObject *obj;
39701 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39702 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
39703 Py_INCREF(obj);
39704 return Py_BuildValue((char *)"");
39705 }
39706 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39707 PyObject *resultobj;
39708 int arg1 = (int) 1 ;
39709 int arg2 = (int) 0 ;
39710 int arg3 = (int) 0 ;
39711 int arg4 = (int) 0 ;
39712 wxGridSizer *result;
39713 PyObject * obj0 = 0 ;
39714 PyObject * obj1 = 0 ;
39715 PyObject * obj2 = 0 ;
39716 PyObject * obj3 = 0 ;
39717 char *kwnames[] = {
39718 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
39719 };
39720
39721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39722 if (obj0) {
39723 {
39724 arg1 = (int)(SWIG_As_int(obj0));
39725 if (SWIG_arg_fail(1)) SWIG_fail;
39726 }
39727 }
39728 if (obj1) {
39729 {
39730 arg2 = (int)(SWIG_As_int(obj1));
39731 if (SWIG_arg_fail(2)) SWIG_fail;
39732 }
39733 }
39734 if (obj2) {
39735 {
39736 arg3 = (int)(SWIG_As_int(obj2));
39737 if (SWIG_arg_fail(3)) SWIG_fail;
39738 }
39739 }
39740 if (obj3) {
39741 {
39742 arg4 = (int)(SWIG_As_int(obj3));
39743 if (SWIG_arg_fail(4)) SWIG_fail;
39744 }
39745 }
39746 {
39747 PyThreadState* __tstate = wxPyBeginAllowThreads();
39748 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
39749
39750 wxPyEndAllowThreads(__tstate);
39751 if (PyErr_Occurred()) SWIG_fail;
39752 }
39753 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
39754 return resultobj;
39755 fail:
39756 return NULL;
39757 }
39758
39759
39760 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
39761 PyObject *resultobj;
39762 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39763 int arg2 ;
39764 PyObject * obj0 = 0 ;
39765 PyObject * obj1 = 0 ;
39766 char *kwnames[] = {
39767 (char *) "self",(char *) "cols", NULL
39768 };
39769
39770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
39771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39772 if (SWIG_arg_fail(1)) SWIG_fail;
39773 {
39774 arg2 = (int)(SWIG_As_int(obj1));
39775 if (SWIG_arg_fail(2)) SWIG_fail;
39776 }
39777 {
39778 PyThreadState* __tstate = wxPyBeginAllowThreads();
39779 (arg1)->SetCols(arg2);
39780
39781 wxPyEndAllowThreads(__tstate);
39782 if (PyErr_Occurred()) SWIG_fail;
39783 }
39784 Py_INCREF(Py_None); resultobj = Py_None;
39785 return resultobj;
39786 fail:
39787 return NULL;
39788 }
39789
39790
39791 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
39792 PyObject *resultobj;
39793 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39794 int arg2 ;
39795 PyObject * obj0 = 0 ;
39796 PyObject * obj1 = 0 ;
39797 char *kwnames[] = {
39798 (char *) "self",(char *) "rows", NULL
39799 };
39800
39801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
39802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39803 if (SWIG_arg_fail(1)) SWIG_fail;
39804 {
39805 arg2 = (int)(SWIG_As_int(obj1));
39806 if (SWIG_arg_fail(2)) SWIG_fail;
39807 }
39808 {
39809 PyThreadState* __tstate = wxPyBeginAllowThreads();
39810 (arg1)->SetRows(arg2);
39811
39812 wxPyEndAllowThreads(__tstate);
39813 if (PyErr_Occurred()) SWIG_fail;
39814 }
39815 Py_INCREF(Py_None); resultobj = Py_None;
39816 return resultobj;
39817 fail:
39818 return NULL;
39819 }
39820
39821
39822 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
39823 PyObject *resultobj;
39824 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39825 int arg2 ;
39826 PyObject * obj0 = 0 ;
39827 PyObject * obj1 = 0 ;
39828 char *kwnames[] = {
39829 (char *) "self",(char *) "gap", NULL
39830 };
39831
39832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
39833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39834 if (SWIG_arg_fail(1)) SWIG_fail;
39835 {
39836 arg2 = (int)(SWIG_As_int(obj1));
39837 if (SWIG_arg_fail(2)) SWIG_fail;
39838 }
39839 {
39840 PyThreadState* __tstate = wxPyBeginAllowThreads();
39841 (arg1)->SetVGap(arg2);
39842
39843 wxPyEndAllowThreads(__tstate);
39844 if (PyErr_Occurred()) SWIG_fail;
39845 }
39846 Py_INCREF(Py_None); resultobj = Py_None;
39847 return resultobj;
39848 fail:
39849 return NULL;
39850 }
39851
39852
39853 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
39854 PyObject *resultobj;
39855 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39856 int arg2 ;
39857 PyObject * obj0 = 0 ;
39858 PyObject * obj1 = 0 ;
39859 char *kwnames[] = {
39860 (char *) "self",(char *) "gap", NULL
39861 };
39862
39863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
39864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39865 if (SWIG_arg_fail(1)) SWIG_fail;
39866 {
39867 arg2 = (int)(SWIG_As_int(obj1));
39868 if (SWIG_arg_fail(2)) SWIG_fail;
39869 }
39870 {
39871 PyThreadState* __tstate = wxPyBeginAllowThreads();
39872 (arg1)->SetHGap(arg2);
39873
39874 wxPyEndAllowThreads(__tstate);
39875 if (PyErr_Occurred()) SWIG_fail;
39876 }
39877 Py_INCREF(Py_None); resultobj = Py_None;
39878 return resultobj;
39879 fail:
39880 return NULL;
39881 }
39882
39883
39884 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
39885 PyObject *resultobj;
39886 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39887 int result;
39888 PyObject * obj0 = 0 ;
39889 char *kwnames[] = {
39890 (char *) "self", NULL
39891 };
39892
39893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
39894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39895 if (SWIG_arg_fail(1)) SWIG_fail;
39896 {
39897 PyThreadState* __tstate = wxPyBeginAllowThreads();
39898 result = (int)(arg1)->GetCols();
39899
39900 wxPyEndAllowThreads(__tstate);
39901 if (PyErr_Occurred()) SWIG_fail;
39902 }
39903 {
39904 resultobj = SWIG_From_int((int)(result));
39905 }
39906 return resultobj;
39907 fail:
39908 return NULL;
39909 }
39910
39911
39912 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
39913 PyObject *resultobj;
39914 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39915 int result;
39916 PyObject * obj0 = 0 ;
39917 char *kwnames[] = {
39918 (char *) "self", NULL
39919 };
39920
39921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
39922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39923 if (SWIG_arg_fail(1)) SWIG_fail;
39924 {
39925 PyThreadState* __tstate = wxPyBeginAllowThreads();
39926 result = (int)(arg1)->GetRows();
39927
39928 wxPyEndAllowThreads(__tstate);
39929 if (PyErr_Occurred()) SWIG_fail;
39930 }
39931 {
39932 resultobj = SWIG_From_int((int)(result));
39933 }
39934 return resultobj;
39935 fail:
39936 return NULL;
39937 }
39938
39939
39940 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
39941 PyObject *resultobj;
39942 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39943 int result;
39944 PyObject * obj0 = 0 ;
39945 char *kwnames[] = {
39946 (char *) "self", NULL
39947 };
39948
39949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
39950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39951 if (SWIG_arg_fail(1)) SWIG_fail;
39952 {
39953 PyThreadState* __tstate = wxPyBeginAllowThreads();
39954 result = (int)(arg1)->GetVGap();
39955
39956 wxPyEndAllowThreads(__tstate);
39957 if (PyErr_Occurred()) SWIG_fail;
39958 }
39959 {
39960 resultobj = SWIG_From_int((int)(result));
39961 }
39962 return resultobj;
39963 fail:
39964 return NULL;
39965 }
39966
39967
39968 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
39969 PyObject *resultobj;
39970 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39971 int result;
39972 PyObject * obj0 = 0 ;
39973 char *kwnames[] = {
39974 (char *) "self", NULL
39975 };
39976
39977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
39978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39979 if (SWIG_arg_fail(1)) SWIG_fail;
39980 {
39981 PyThreadState* __tstate = wxPyBeginAllowThreads();
39982 result = (int)(arg1)->GetHGap();
39983
39984 wxPyEndAllowThreads(__tstate);
39985 if (PyErr_Occurred()) SWIG_fail;
39986 }
39987 {
39988 resultobj = SWIG_From_int((int)(result));
39989 }
39990 return resultobj;
39991 fail:
39992 return NULL;
39993 }
39994
39995
39996 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
39997 PyObject *obj;
39998 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39999 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
40000 Py_INCREF(obj);
40001 return Py_BuildValue((char *)"");
40002 }
40003 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40004 PyObject *resultobj;
40005 int arg1 = (int) 1 ;
40006 int arg2 = (int) 0 ;
40007 int arg3 = (int) 0 ;
40008 int arg4 = (int) 0 ;
40009 wxFlexGridSizer *result;
40010 PyObject * obj0 = 0 ;
40011 PyObject * obj1 = 0 ;
40012 PyObject * obj2 = 0 ;
40013 PyObject * obj3 = 0 ;
40014 char *kwnames[] = {
40015 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40016 };
40017
40018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40019 if (obj0) {
40020 {
40021 arg1 = (int)(SWIG_As_int(obj0));
40022 if (SWIG_arg_fail(1)) SWIG_fail;
40023 }
40024 }
40025 if (obj1) {
40026 {
40027 arg2 = (int)(SWIG_As_int(obj1));
40028 if (SWIG_arg_fail(2)) SWIG_fail;
40029 }
40030 }
40031 if (obj2) {
40032 {
40033 arg3 = (int)(SWIG_As_int(obj2));
40034 if (SWIG_arg_fail(3)) SWIG_fail;
40035 }
40036 }
40037 if (obj3) {
40038 {
40039 arg4 = (int)(SWIG_As_int(obj3));
40040 if (SWIG_arg_fail(4)) SWIG_fail;
40041 }
40042 }
40043 {
40044 PyThreadState* __tstate = wxPyBeginAllowThreads();
40045 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
40046
40047 wxPyEndAllowThreads(__tstate);
40048 if (PyErr_Occurred()) SWIG_fail;
40049 }
40050 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
40051 return resultobj;
40052 fail:
40053 return NULL;
40054 }
40055
40056
40057 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40058 PyObject *resultobj;
40059 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40060 size_t arg2 ;
40061 int arg3 = (int) 0 ;
40062 PyObject * obj0 = 0 ;
40063 PyObject * obj1 = 0 ;
40064 PyObject * obj2 = 0 ;
40065 char *kwnames[] = {
40066 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40067 };
40068
40069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
40070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40071 if (SWIG_arg_fail(1)) SWIG_fail;
40072 {
40073 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40074 if (SWIG_arg_fail(2)) SWIG_fail;
40075 }
40076 if (obj2) {
40077 {
40078 arg3 = (int)(SWIG_As_int(obj2));
40079 if (SWIG_arg_fail(3)) SWIG_fail;
40080 }
40081 }
40082 {
40083 PyThreadState* __tstate = wxPyBeginAllowThreads();
40084 (arg1)->AddGrowableRow(arg2,arg3);
40085
40086 wxPyEndAllowThreads(__tstate);
40087 if (PyErr_Occurred()) SWIG_fail;
40088 }
40089 Py_INCREF(Py_None); resultobj = Py_None;
40090 return resultobj;
40091 fail:
40092 return NULL;
40093 }
40094
40095
40096 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40097 PyObject *resultobj;
40098 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40099 size_t arg2 ;
40100 PyObject * obj0 = 0 ;
40101 PyObject * obj1 = 0 ;
40102 char *kwnames[] = {
40103 (char *) "self",(char *) "idx", NULL
40104 };
40105
40106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
40107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40108 if (SWIG_arg_fail(1)) SWIG_fail;
40109 {
40110 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40111 if (SWIG_arg_fail(2)) SWIG_fail;
40112 }
40113 {
40114 PyThreadState* __tstate = wxPyBeginAllowThreads();
40115 (arg1)->RemoveGrowableRow(arg2);
40116
40117 wxPyEndAllowThreads(__tstate);
40118 if (PyErr_Occurred()) SWIG_fail;
40119 }
40120 Py_INCREF(Py_None); resultobj = Py_None;
40121 return resultobj;
40122 fail:
40123 return NULL;
40124 }
40125
40126
40127 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40128 PyObject *resultobj;
40129 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40130 size_t arg2 ;
40131 int arg3 = (int) 0 ;
40132 PyObject * obj0 = 0 ;
40133 PyObject * obj1 = 0 ;
40134 PyObject * obj2 = 0 ;
40135 char *kwnames[] = {
40136 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40137 };
40138
40139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
40140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40141 if (SWIG_arg_fail(1)) SWIG_fail;
40142 {
40143 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40144 if (SWIG_arg_fail(2)) SWIG_fail;
40145 }
40146 if (obj2) {
40147 {
40148 arg3 = (int)(SWIG_As_int(obj2));
40149 if (SWIG_arg_fail(3)) SWIG_fail;
40150 }
40151 }
40152 {
40153 PyThreadState* __tstate = wxPyBeginAllowThreads();
40154 (arg1)->AddGrowableCol(arg2,arg3);
40155
40156 wxPyEndAllowThreads(__tstate);
40157 if (PyErr_Occurred()) SWIG_fail;
40158 }
40159 Py_INCREF(Py_None); resultobj = Py_None;
40160 return resultobj;
40161 fail:
40162 return NULL;
40163 }
40164
40165
40166 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40167 PyObject *resultobj;
40168 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40169 size_t arg2 ;
40170 PyObject * obj0 = 0 ;
40171 PyObject * obj1 = 0 ;
40172 char *kwnames[] = {
40173 (char *) "self",(char *) "idx", NULL
40174 };
40175
40176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
40177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40178 if (SWIG_arg_fail(1)) SWIG_fail;
40179 {
40180 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40181 if (SWIG_arg_fail(2)) SWIG_fail;
40182 }
40183 {
40184 PyThreadState* __tstate = wxPyBeginAllowThreads();
40185 (arg1)->RemoveGrowableCol(arg2);
40186
40187 wxPyEndAllowThreads(__tstate);
40188 if (PyErr_Occurred()) SWIG_fail;
40189 }
40190 Py_INCREF(Py_None); resultobj = Py_None;
40191 return resultobj;
40192 fail:
40193 return NULL;
40194 }
40195
40196
40197 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40198 PyObject *resultobj;
40199 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40200 int arg2 ;
40201 PyObject * obj0 = 0 ;
40202 PyObject * obj1 = 0 ;
40203 char *kwnames[] = {
40204 (char *) "self",(char *) "direction", NULL
40205 };
40206
40207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
40208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40209 if (SWIG_arg_fail(1)) SWIG_fail;
40210 {
40211 arg2 = (int)(SWIG_As_int(obj1));
40212 if (SWIG_arg_fail(2)) SWIG_fail;
40213 }
40214 {
40215 PyThreadState* __tstate = wxPyBeginAllowThreads();
40216 (arg1)->SetFlexibleDirection(arg2);
40217
40218 wxPyEndAllowThreads(__tstate);
40219 if (PyErr_Occurred()) SWIG_fail;
40220 }
40221 Py_INCREF(Py_None); resultobj = Py_None;
40222 return resultobj;
40223 fail:
40224 return NULL;
40225 }
40226
40227
40228 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40229 PyObject *resultobj;
40230 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40231 int result;
40232 PyObject * obj0 = 0 ;
40233 char *kwnames[] = {
40234 (char *) "self", NULL
40235 };
40236
40237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
40238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40239 if (SWIG_arg_fail(1)) SWIG_fail;
40240 {
40241 PyThreadState* __tstate = wxPyBeginAllowThreads();
40242 result = (int)(arg1)->GetFlexibleDirection();
40243
40244 wxPyEndAllowThreads(__tstate);
40245 if (PyErr_Occurred()) SWIG_fail;
40246 }
40247 {
40248 resultobj = SWIG_From_int((int)(result));
40249 }
40250 return resultobj;
40251 fail:
40252 return NULL;
40253 }
40254
40255
40256 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40257 PyObject *resultobj;
40258 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40259 wxFlexSizerGrowMode arg2 ;
40260 PyObject * obj0 = 0 ;
40261 PyObject * obj1 = 0 ;
40262 char *kwnames[] = {
40263 (char *) "self",(char *) "mode", NULL
40264 };
40265
40266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
40267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40268 if (SWIG_arg_fail(1)) SWIG_fail;
40269 {
40270 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
40271 if (SWIG_arg_fail(2)) SWIG_fail;
40272 }
40273 {
40274 PyThreadState* __tstate = wxPyBeginAllowThreads();
40275 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
40276
40277 wxPyEndAllowThreads(__tstate);
40278 if (PyErr_Occurred()) SWIG_fail;
40279 }
40280 Py_INCREF(Py_None); resultobj = Py_None;
40281 return resultobj;
40282 fail:
40283 return NULL;
40284 }
40285
40286
40287 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40288 PyObject *resultobj;
40289 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40290 wxFlexSizerGrowMode result;
40291 PyObject * obj0 = 0 ;
40292 char *kwnames[] = {
40293 (char *) "self", NULL
40294 };
40295
40296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
40297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40298 if (SWIG_arg_fail(1)) SWIG_fail;
40299 {
40300 PyThreadState* __tstate = wxPyBeginAllowThreads();
40301 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
40302
40303 wxPyEndAllowThreads(__tstate);
40304 if (PyErr_Occurred()) SWIG_fail;
40305 }
40306 resultobj = SWIG_From_int((result));
40307 return resultobj;
40308 fail:
40309 return NULL;
40310 }
40311
40312
40313 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
40314 PyObject *resultobj;
40315 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40316 wxArrayInt *result;
40317 PyObject * obj0 = 0 ;
40318 char *kwnames[] = {
40319 (char *) "self", NULL
40320 };
40321
40322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
40323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40324 if (SWIG_arg_fail(1)) SWIG_fail;
40325 {
40326 PyThreadState* __tstate = wxPyBeginAllowThreads();
40327 {
40328 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
40329 result = (wxArrayInt *) &_result_ref;
40330 }
40331
40332 wxPyEndAllowThreads(__tstate);
40333 if (PyErr_Occurred()) SWIG_fail;
40334 }
40335 {
40336 resultobj = PyList_New(0);
40337 size_t idx;
40338 for (idx = 0; idx < result->GetCount(); idx += 1) {
40339 PyObject* val = PyInt_FromLong( result->Item(idx) );
40340 PyList_Append(resultobj, val);
40341 Py_DECREF(val);
40342 }
40343 }
40344 return resultobj;
40345 fail:
40346 return NULL;
40347 }
40348
40349
40350 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
40351 PyObject *resultobj;
40352 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40353 wxArrayInt *result;
40354 PyObject * obj0 = 0 ;
40355 char *kwnames[] = {
40356 (char *) "self", NULL
40357 };
40358
40359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
40360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40361 if (SWIG_arg_fail(1)) SWIG_fail;
40362 {
40363 PyThreadState* __tstate = wxPyBeginAllowThreads();
40364 {
40365 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
40366 result = (wxArrayInt *) &_result_ref;
40367 }
40368
40369 wxPyEndAllowThreads(__tstate);
40370 if (PyErr_Occurred()) SWIG_fail;
40371 }
40372 {
40373 resultobj = PyList_New(0);
40374 size_t idx;
40375 for (idx = 0; idx < result->GetCount(); idx += 1) {
40376 PyObject* val = PyInt_FromLong( result->Item(idx) );
40377 PyList_Append(resultobj, val);
40378 Py_DECREF(val);
40379 }
40380 }
40381 return resultobj;
40382 fail:
40383 return NULL;
40384 }
40385
40386
40387 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
40388 PyObject *obj;
40389 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40390 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
40391 Py_INCREF(obj);
40392 return Py_BuildValue((char *)"");
40393 }
40394 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40395 PyObject *resultobj;
40396 wxStdDialogButtonSizer *result;
40397 char *kwnames[] = {
40398 NULL
40399 };
40400
40401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
40402 {
40403 PyThreadState* __tstate = wxPyBeginAllowThreads();
40404 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
40405
40406 wxPyEndAllowThreads(__tstate);
40407 if (PyErr_Occurred()) SWIG_fail;
40408 }
40409 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
40410 return resultobj;
40411 fail:
40412 return NULL;
40413 }
40414
40415
40416 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
40417 PyObject *resultobj;
40418 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40419 wxButton *arg2 = (wxButton *) 0 ;
40420 PyObject * obj0 = 0 ;
40421 PyObject * obj1 = 0 ;
40422 char *kwnames[] = {
40423 (char *) "self",(char *) "button", NULL
40424 };
40425
40426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
40427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40428 if (SWIG_arg_fail(1)) SWIG_fail;
40429 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40430 if (SWIG_arg_fail(2)) SWIG_fail;
40431 {
40432 PyThreadState* __tstate = wxPyBeginAllowThreads();
40433 (arg1)->AddButton(arg2);
40434
40435 wxPyEndAllowThreads(__tstate);
40436 if (PyErr_Occurred()) SWIG_fail;
40437 }
40438 Py_INCREF(Py_None); resultobj = Py_None;
40439 return resultobj;
40440 fail:
40441 return NULL;
40442 }
40443
40444
40445 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
40446 PyObject *resultobj;
40447 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40448 PyObject * obj0 = 0 ;
40449 char *kwnames[] = {
40450 (char *) "self", NULL
40451 };
40452
40453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
40454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40455 if (SWIG_arg_fail(1)) SWIG_fail;
40456 {
40457 PyThreadState* __tstate = wxPyBeginAllowThreads();
40458 (arg1)->Realize();
40459
40460 wxPyEndAllowThreads(__tstate);
40461 if (PyErr_Occurred()) SWIG_fail;
40462 }
40463 Py_INCREF(Py_None); resultobj = Py_None;
40464 return resultobj;
40465 fail:
40466 return NULL;
40467 }
40468
40469
40470 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40471 PyObject *resultobj;
40472 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40473 wxButton *arg2 = (wxButton *) 0 ;
40474 PyObject * obj0 = 0 ;
40475 PyObject * obj1 = 0 ;
40476 char *kwnames[] = {
40477 (char *) "self",(char *) "button", NULL
40478 };
40479
40480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
40481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40482 if (SWIG_arg_fail(1)) SWIG_fail;
40483 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40484 if (SWIG_arg_fail(2)) SWIG_fail;
40485 {
40486 PyThreadState* __tstate = wxPyBeginAllowThreads();
40487 (arg1)->SetAffirmativeButton(arg2);
40488
40489 wxPyEndAllowThreads(__tstate);
40490 if (PyErr_Occurred()) SWIG_fail;
40491 }
40492 Py_INCREF(Py_None); resultobj = Py_None;
40493 return resultobj;
40494 fail:
40495 return NULL;
40496 }
40497
40498
40499 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40500 PyObject *resultobj;
40501 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40502 wxButton *arg2 = (wxButton *) 0 ;
40503 PyObject * obj0 = 0 ;
40504 PyObject * obj1 = 0 ;
40505 char *kwnames[] = {
40506 (char *) "self",(char *) "button", NULL
40507 };
40508
40509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
40510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40511 if (SWIG_arg_fail(1)) SWIG_fail;
40512 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40513 if (SWIG_arg_fail(2)) SWIG_fail;
40514 {
40515 PyThreadState* __tstate = wxPyBeginAllowThreads();
40516 (arg1)->SetNegativeButton(arg2);
40517
40518 wxPyEndAllowThreads(__tstate);
40519 if (PyErr_Occurred()) SWIG_fail;
40520 }
40521 Py_INCREF(Py_None); resultobj = Py_None;
40522 return resultobj;
40523 fail:
40524 return NULL;
40525 }
40526
40527
40528 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
40529 PyObject *resultobj;
40530 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40531 wxButton *arg2 = (wxButton *) 0 ;
40532 PyObject * obj0 = 0 ;
40533 PyObject * obj1 = 0 ;
40534 char *kwnames[] = {
40535 (char *) "self",(char *) "button", NULL
40536 };
40537
40538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
40539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40540 if (SWIG_arg_fail(1)) SWIG_fail;
40541 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40542 if (SWIG_arg_fail(2)) SWIG_fail;
40543 {
40544 PyThreadState* __tstate = wxPyBeginAllowThreads();
40545 (arg1)->SetCancelButton(arg2);
40546
40547 wxPyEndAllowThreads(__tstate);
40548 if (PyErr_Occurred()) SWIG_fail;
40549 }
40550 Py_INCREF(Py_None); resultobj = Py_None;
40551 return resultobj;
40552 fail:
40553 return NULL;
40554 }
40555
40556
40557 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40558 PyObject *resultobj;
40559 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40560 wxButton *result;
40561 PyObject * obj0 = 0 ;
40562 char *kwnames[] = {
40563 (char *) "self", NULL
40564 };
40565
40566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
40567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40568 if (SWIG_arg_fail(1)) SWIG_fail;
40569 {
40570 PyThreadState* __tstate = wxPyBeginAllowThreads();
40571 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
40572
40573 wxPyEndAllowThreads(__tstate);
40574 if (PyErr_Occurred()) SWIG_fail;
40575 }
40576 {
40577 resultobj = wxPyMake_wxObject(result, 0);
40578 }
40579 return resultobj;
40580 fail:
40581 return NULL;
40582 }
40583
40584
40585 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
40586 PyObject *resultobj;
40587 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40588 wxButton *result;
40589 PyObject * obj0 = 0 ;
40590 char *kwnames[] = {
40591 (char *) "self", NULL
40592 };
40593
40594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
40595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40596 if (SWIG_arg_fail(1)) SWIG_fail;
40597 {
40598 PyThreadState* __tstate = wxPyBeginAllowThreads();
40599 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
40600
40601 wxPyEndAllowThreads(__tstate);
40602 if (PyErr_Occurred()) SWIG_fail;
40603 }
40604 {
40605 resultobj = wxPyMake_wxObject(result, 0);
40606 }
40607 return resultobj;
40608 fail:
40609 return NULL;
40610 }
40611
40612
40613 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40614 PyObject *resultobj;
40615 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40616 wxButton *result;
40617 PyObject * obj0 = 0 ;
40618 char *kwnames[] = {
40619 (char *) "self", NULL
40620 };
40621
40622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
40623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40624 if (SWIG_arg_fail(1)) SWIG_fail;
40625 {
40626 PyThreadState* __tstate = wxPyBeginAllowThreads();
40627 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
40628
40629 wxPyEndAllowThreads(__tstate);
40630 if (PyErr_Occurred()) SWIG_fail;
40631 }
40632 {
40633 resultobj = wxPyMake_wxObject(result, 0);
40634 }
40635 return resultobj;
40636 fail:
40637 return NULL;
40638 }
40639
40640
40641 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
40642 PyObject *resultobj;
40643 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40644 wxButton *result;
40645 PyObject * obj0 = 0 ;
40646 char *kwnames[] = {
40647 (char *) "self", NULL
40648 };
40649
40650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
40651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40652 if (SWIG_arg_fail(1)) SWIG_fail;
40653 {
40654 PyThreadState* __tstate = wxPyBeginAllowThreads();
40655 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
40656
40657 wxPyEndAllowThreads(__tstate);
40658 if (PyErr_Occurred()) SWIG_fail;
40659 }
40660 {
40661 resultobj = wxPyMake_wxObject(result, 0);
40662 }
40663 return resultobj;
40664 fail:
40665 return NULL;
40666 }
40667
40668
40669 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
40670 PyObject *resultobj;
40671 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40672 wxButton *result;
40673 PyObject * obj0 = 0 ;
40674 char *kwnames[] = {
40675 (char *) "self", NULL
40676 };
40677
40678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
40679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40680 if (SWIG_arg_fail(1)) SWIG_fail;
40681 {
40682 PyThreadState* __tstate = wxPyBeginAllowThreads();
40683 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
40684
40685 wxPyEndAllowThreads(__tstate);
40686 if (PyErr_Occurred()) SWIG_fail;
40687 }
40688 {
40689 resultobj = wxPyMake_wxObject(result, 0);
40690 }
40691 return resultobj;
40692 fail:
40693 return NULL;
40694 }
40695
40696
40697 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
40698 PyObject *obj;
40699 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40700 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
40701 Py_INCREF(obj);
40702 return Py_BuildValue((char *)"");
40703 }
40704 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40705 PyObject *resultobj;
40706 int arg1 = (int) 0 ;
40707 int arg2 = (int) 0 ;
40708 wxGBPosition *result;
40709 PyObject * obj0 = 0 ;
40710 PyObject * obj1 = 0 ;
40711 char *kwnames[] = {
40712 (char *) "row",(char *) "col", NULL
40713 };
40714
40715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
40716 if (obj0) {
40717 {
40718 arg1 = (int)(SWIG_As_int(obj0));
40719 if (SWIG_arg_fail(1)) SWIG_fail;
40720 }
40721 }
40722 if (obj1) {
40723 {
40724 arg2 = (int)(SWIG_As_int(obj1));
40725 if (SWIG_arg_fail(2)) SWIG_fail;
40726 }
40727 }
40728 {
40729 PyThreadState* __tstate = wxPyBeginAllowThreads();
40730 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
40731
40732 wxPyEndAllowThreads(__tstate);
40733 if (PyErr_Occurred()) SWIG_fail;
40734 }
40735 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
40736 return resultobj;
40737 fail:
40738 return NULL;
40739 }
40740
40741
40742 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
40743 PyObject *resultobj;
40744 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40745 int result;
40746 PyObject * obj0 = 0 ;
40747 char *kwnames[] = {
40748 (char *) "self", NULL
40749 };
40750
40751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
40752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40753 if (SWIG_arg_fail(1)) SWIG_fail;
40754 {
40755 PyThreadState* __tstate = wxPyBeginAllowThreads();
40756 result = (int)((wxGBPosition const *)arg1)->GetRow();
40757
40758 wxPyEndAllowThreads(__tstate);
40759 if (PyErr_Occurred()) SWIG_fail;
40760 }
40761 {
40762 resultobj = SWIG_From_int((int)(result));
40763 }
40764 return resultobj;
40765 fail:
40766 return NULL;
40767 }
40768
40769
40770 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
40771 PyObject *resultobj;
40772 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40773 int result;
40774 PyObject * obj0 = 0 ;
40775 char *kwnames[] = {
40776 (char *) "self", NULL
40777 };
40778
40779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
40780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40781 if (SWIG_arg_fail(1)) SWIG_fail;
40782 {
40783 PyThreadState* __tstate = wxPyBeginAllowThreads();
40784 result = (int)((wxGBPosition const *)arg1)->GetCol();
40785
40786 wxPyEndAllowThreads(__tstate);
40787 if (PyErr_Occurred()) SWIG_fail;
40788 }
40789 {
40790 resultobj = SWIG_From_int((int)(result));
40791 }
40792 return resultobj;
40793 fail:
40794 return NULL;
40795 }
40796
40797
40798 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
40799 PyObject *resultobj;
40800 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40801 int arg2 ;
40802 PyObject * obj0 = 0 ;
40803 PyObject * obj1 = 0 ;
40804 char *kwnames[] = {
40805 (char *) "self",(char *) "row", NULL
40806 };
40807
40808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
40809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40810 if (SWIG_arg_fail(1)) SWIG_fail;
40811 {
40812 arg2 = (int)(SWIG_As_int(obj1));
40813 if (SWIG_arg_fail(2)) SWIG_fail;
40814 }
40815 {
40816 PyThreadState* __tstate = wxPyBeginAllowThreads();
40817 (arg1)->SetRow(arg2);
40818
40819 wxPyEndAllowThreads(__tstate);
40820 if (PyErr_Occurred()) SWIG_fail;
40821 }
40822 Py_INCREF(Py_None); resultobj = Py_None;
40823 return resultobj;
40824 fail:
40825 return NULL;
40826 }
40827
40828
40829 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
40830 PyObject *resultobj;
40831 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40832 int arg2 ;
40833 PyObject * obj0 = 0 ;
40834 PyObject * obj1 = 0 ;
40835 char *kwnames[] = {
40836 (char *) "self",(char *) "col", NULL
40837 };
40838
40839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
40840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40841 if (SWIG_arg_fail(1)) SWIG_fail;
40842 {
40843 arg2 = (int)(SWIG_As_int(obj1));
40844 if (SWIG_arg_fail(2)) SWIG_fail;
40845 }
40846 {
40847 PyThreadState* __tstate = wxPyBeginAllowThreads();
40848 (arg1)->SetCol(arg2);
40849
40850 wxPyEndAllowThreads(__tstate);
40851 if (PyErr_Occurred()) SWIG_fail;
40852 }
40853 Py_INCREF(Py_None); resultobj = Py_None;
40854 return resultobj;
40855 fail:
40856 return NULL;
40857 }
40858
40859
40860 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
40861 PyObject *resultobj;
40862 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40863 wxGBPosition *arg2 = 0 ;
40864 bool result;
40865 wxGBPosition temp2 ;
40866 PyObject * obj0 = 0 ;
40867 PyObject * obj1 = 0 ;
40868 char *kwnames[] = {
40869 (char *) "self",(char *) "other", NULL
40870 };
40871
40872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
40873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40874 if (SWIG_arg_fail(1)) SWIG_fail;
40875 {
40876 arg2 = &temp2;
40877 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40878 }
40879 {
40880 PyThreadState* __tstate = wxPyBeginAllowThreads();
40881 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
40882
40883 wxPyEndAllowThreads(__tstate);
40884 if (PyErr_Occurred()) SWIG_fail;
40885 }
40886 {
40887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40888 }
40889 return resultobj;
40890 fail:
40891 return NULL;
40892 }
40893
40894
40895 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
40896 PyObject *resultobj;
40897 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40898 wxGBPosition *arg2 = 0 ;
40899 bool result;
40900 wxGBPosition temp2 ;
40901 PyObject * obj0 = 0 ;
40902 PyObject * obj1 = 0 ;
40903 char *kwnames[] = {
40904 (char *) "self",(char *) "other", NULL
40905 };
40906
40907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
40908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40909 if (SWIG_arg_fail(1)) SWIG_fail;
40910 {
40911 arg2 = &temp2;
40912 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40913 }
40914 {
40915 PyThreadState* __tstate = wxPyBeginAllowThreads();
40916 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
40917
40918 wxPyEndAllowThreads(__tstate);
40919 if (PyErr_Occurred()) SWIG_fail;
40920 }
40921 {
40922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40923 }
40924 return resultobj;
40925 fail:
40926 return NULL;
40927 }
40928
40929
40930 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
40931 PyObject *resultobj;
40932 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40933 int arg2 = (int) 0 ;
40934 int arg3 = (int) 0 ;
40935 PyObject * obj0 = 0 ;
40936 PyObject * obj1 = 0 ;
40937 PyObject * obj2 = 0 ;
40938 char *kwnames[] = {
40939 (char *) "self",(char *) "row",(char *) "col", NULL
40940 };
40941
40942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
40943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40944 if (SWIG_arg_fail(1)) SWIG_fail;
40945 if (obj1) {
40946 {
40947 arg2 = (int)(SWIG_As_int(obj1));
40948 if (SWIG_arg_fail(2)) SWIG_fail;
40949 }
40950 }
40951 if (obj2) {
40952 {
40953 arg3 = (int)(SWIG_As_int(obj2));
40954 if (SWIG_arg_fail(3)) SWIG_fail;
40955 }
40956 }
40957 {
40958 PyThreadState* __tstate = wxPyBeginAllowThreads();
40959 wxGBPosition_Set(arg1,arg2,arg3);
40960
40961 wxPyEndAllowThreads(__tstate);
40962 if (PyErr_Occurred()) SWIG_fail;
40963 }
40964 Py_INCREF(Py_None); resultobj = Py_None;
40965 return resultobj;
40966 fail:
40967 return NULL;
40968 }
40969
40970
40971 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
40972 PyObject *resultobj;
40973 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40974 PyObject *result;
40975 PyObject * obj0 = 0 ;
40976 char *kwnames[] = {
40977 (char *) "self", NULL
40978 };
40979
40980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
40981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40982 if (SWIG_arg_fail(1)) SWIG_fail;
40983 {
40984 PyThreadState* __tstate = wxPyBeginAllowThreads();
40985 result = (PyObject *)wxGBPosition_Get(arg1);
40986
40987 wxPyEndAllowThreads(__tstate);
40988 if (PyErr_Occurred()) SWIG_fail;
40989 }
40990 resultobj = result;
40991 return resultobj;
40992 fail:
40993 return NULL;
40994 }
40995
40996
40997 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
40998 PyObject *obj;
40999 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41000 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
41001 Py_INCREF(obj);
41002 return Py_BuildValue((char *)"");
41003 }
41004 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41005 PyObject *resultobj;
41006 int arg1 = (int) 1 ;
41007 int arg2 = (int) 1 ;
41008 wxGBSpan *result;
41009 PyObject * obj0 = 0 ;
41010 PyObject * obj1 = 0 ;
41011 char *kwnames[] = {
41012 (char *) "rowspan",(char *) "colspan", NULL
41013 };
41014
41015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
41016 if (obj0) {
41017 {
41018 arg1 = (int)(SWIG_As_int(obj0));
41019 if (SWIG_arg_fail(1)) SWIG_fail;
41020 }
41021 }
41022 if (obj1) {
41023 {
41024 arg2 = (int)(SWIG_As_int(obj1));
41025 if (SWIG_arg_fail(2)) SWIG_fail;
41026 }
41027 }
41028 {
41029 PyThreadState* __tstate = wxPyBeginAllowThreads();
41030 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
41031
41032 wxPyEndAllowThreads(__tstate);
41033 if (PyErr_Occurred()) SWIG_fail;
41034 }
41035 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
41036 return resultobj;
41037 fail:
41038 return NULL;
41039 }
41040
41041
41042 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41043 PyObject *resultobj;
41044 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41045 int result;
41046 PyObject * obj0 = 0 ;
41047 char *kwnames[] = {
41048 (char *) "self", NULL
41049 };
41050
41051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
41052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41053 if (SWIG_arg_fail(1)) SWIG_fail;
41054 {
41055 PyThreadState* __tstate = wxPyBeginAllowThreads();
41056 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
41057
41058 wxPyEndAllowThreads(__tstate);
41059 if (PyErr_Occurred()) SWIG_fail;
41060 }
41061 {
41062 resultobj = SWIG_From_int((int)(result));
41063 }
41064 return resultobj;
41065 fail:
41066 return NULL;
41067 }
41068
41069
41070 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41071 PyObject *resultobj;
41072 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41073 int result;
41074 PyObject * obj0 = 0 ;
41075 char *kwnames[] = {
41076 (char *) "self", NULL
41077 };
41078
41079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
41080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41081 if (SWIG_arg_fail(1)) SWIG_fail;
41082 {
41083 PyThreadState* __tstate = wxPyBeginAllowThreads();
41084 result = (int)((wxGBSpan const *)arg1)->GetColspan();
41085
41086 wxPyEndAllowThreads(__tstate);
41087 if (PyErr_Occurred()) SWIG_fail;
41088 }
41089 {
41090 resultobj = SWIG_From_int((int)(result));
41091 }
41092 return resultobj;
41093 fail:
41094 return NULL;
41095 }
41096
41097
41098 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41099 PyObject *resultobj;
41100 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41101 int arg2 ;
41102 PyObject * obj0 = 0 ;
41103 PyObject * obj1 = 0 ;
41104 char *kwnames[] = {
41105 (char *) "self",(char *) "rowspan", NULL
41106 };
41107
41108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
41109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41110 if (SWIG_arg_fail(1)) SWIG_fail;
41111 {
41112 arg2 = (int)(SWIG_As_int(obj1));
41113 if (SWIG_arg_fail(2)) SWIG_fail;
41114 }
41115 {
41116 PyThreadState* __tstate = wxPyBeginAllowThreads();
41117 (arg1)->SetRowspan(arg2);
41118
41119 wxPyEndAllowThreads(__tstate);
41120 if (PyErr_Occurred()) SWIG_fail;
41121 }
41122 Py_INCREF(Py_None); resultobj = Py_None;
41123 return resultobj;
41124 fail:
41125 return NULL;
41126 }
41127
41128
41129 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41130 PyObject *resultobj;
41131 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41132 int arg2 ;
41133 PyObject * obj0 = 0 ;
41134 PyObject * obj1 = 0 ;
41135 char *kwnames[] = {
41136 (char *) "self",(char *) "colspan", NULL
41137 };
41138
41139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
41140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41141 if (SWIG_arg_fail(1)) SWIG_fail;
41142 {
41143 arg2 = (int)(SWIG_As_int(obj1));
41144 if (SWIG_arg_fail(2)) SWIG_fail;
41145 }
41146 {
41147 PyThreadState* __tstate = wxPyBeginAllowThreads();
41148 (arg1)->SetColspan(arg2);
41149
41150 wxPyEndAllowThreads(__tstate);
41151 if (PyErr_Occurred()) SWIG_fail;
41152 }
41153 Py_INCREF(Py_None); resultobj = Py_None;
41154 return resultobj;
41155 fail:
41156 return NULL;
41157 }
41158
41159
41160 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41161 PyObject *resultobj;
41162 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41163 wxGBSpan *arg2 = 0 ;
41164 bool result;
41165 wxGBSpan temp2 ;
41166 PyObject * obj0 = 0 ;
41167 PyObject * obj1 = 0 ;
41168 char *kwnames[] = {
41169 (char *) "self",(char *) "other", NULL
41170 };
41171
41172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
41173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41174 if (SWIG_arg_fail(1)) SWIG_fail;
41175 {
41176 arg2 = &temp2;
41177 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41178 }
41179 {
41180 PyThreadState* __tstate = wxPyBeginAllowThreads();
41181 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
41182
41183 wxPyEndAllowThreads(__tstate);
41184 if (PyErr_Occurred()) SWIG_fail;
41185 }
41186 {
41187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41188 }
41189 return resultobj;
41190 fail:
41191 return NULL;
41192 }
41193
41194
41195 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41196 PyObject *resultobj;
41197 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41198 wxGBSpan *arg2 = 0 ;
41199 bool result;
41200 wxGBSpan temp2 ;
41201 PyObject * obj0 = 0 ;
41202 PyObject * obj1 = 0 ;
41203 char *kwnames[] = {
41204 (char *) "self",(char *) "other", NULL
41205 };
41206
41207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
41208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41209 if (SWIG_arg_fail(1)) SWIG_fail;
41210 {
41211 arg2 = &temp2;
41212 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41213 }
41214 {
41215 PyThreadState* __tstate = wxPyBeginAllowThreads();
41216 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
41217
41218 wxPyEndAllowThreads(__tstate);
41219 if (PyErr_Occurred()) SWIG_fail;
41220 }
41221 {
41222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41223 }
41224 return resultobj;
41225 fail:
41226 return NULL;
41227 }
41228
41229
41230 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41231 PyObject *resultobj;
41232 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41233 int arg2 = (int) 1 ;
41234 int arg3 = (int) 1 ;
41235 PyObject * obj0 = 0 ;
41236 PyObject * obj1 = 0 ;
41237 PyObject * obj2 = 0 ;
41238 char *kwnames[] = {
41239 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
41240 };
41241
41242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41244 if (SWIG_arg_fail(1)) SWIG_fail;
41245 if (obj1) {
41246 {
41247 arg2 = (int)(SWIG_As_int(obj1));
41248 if (SWIG_arg_fail(2)) SWIG_fail;
41249 }
41250 }
41251 if (obj2) {
41252 {
41253 arg3 = (int)(SWIG_As_int(obj2));
41254 if (SWIG_arg_fail(3)) SWIG_fail;
41255 }
41256 }
41257 {
41258 PyThreadState* __tstate = wxPyBeginAllowThreads();
41259 wxGBSpan_Set(arg1,arg2,arg3);
41260
41261 wxPyEndAllowThreads(__tstate);
41262 if (PyErr_Occurred()) SWIG_fail;
41263 }
41264 Py_INCREF(Py_None); resultobj = Py_None;
41265 return resultobj;
41266 fail:
41267 return NULL;
41268 }
41269
41270
41271 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41272 PyObject *resultobj;
41273 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41274 PyObject *result;
41275 PyObject * obj0 = 0 ;
41276 char *kwnames[] = {
41277 (char *) "self", NULL
41278 };
41279
41280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
41281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41282 if (SWIG_arg_fail(1)) SWIG_fail;
41283 {
41284 PyThreadState* __tstate = wxPyBeginAllowThreads();
41285 result = (PyObject *)wxGBSpan_Get(arg1);
41286
41287 wxPyEndAllowThreads(__tstate);
41288 if (PyErr_Occurred()) SWIG_fail;
41289 }
41290 resultobj = result;
41291 return resultobj;
41292 fail:
41293 return NULL;
41294 }
41295
41296
41297 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
41298 PyObject *obj;
41299 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41300 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
41301 Py_INCREF(obj);
41302 return Py_BuildValue((char *)"");
41303 }
41304 static int _wrap_DefaultSpan_set(PyObject *) {
41305 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
41306 return 1;
41307 }
41308
41309
41310 static PyObject *_wrap_DefaultSpan_get(void) {
41311 PyObject *pyobj;
41312
41313 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
41314 return pyobj;
41315 }
41316
41317
41318 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
41319 PyObject *resultobj;
41320 wxGBSizerItem *result;
41321 char *kwnames[] = {
41322 NULL
41323 };
41324
41325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
41326 {
41327 PyThreadState* __tstate = wxPyBeginAllowThreads();
41328 result = (wxGBSizerItem *)new wxGBSizerItem();
41329
41330 wxPyEndAllowThreads(__tstate);
41331 if (PyErr_Occurred()) SWIG_fail;
41332 }
41333 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41334 return resultobj;
41335 fail:
41336 return NULL;
41337 }
41338
41339
41340 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
41341 PyObject *resultobj;
41342 wxWindow *arg1 = (wxWindow *) 0 ;
41343 wxGBPosition *arg2 = 0 ;
41344 wxGBSpan *arg3 = 0 ;
41345 int arg4 ;
41346 int arg5 ;
41347 PyObject *arg6 = (PyObject *) NULL ;
41348 wxGBSizerItem *result;
41349 wxGBPosition temp2 ;
41350 wxGBSpan temp3 ;
41351 PyObject * obj0 = 0 ;
41352 PyObject * obj1 = 0 ;
41353 PyObject * obj2 = 0 ;
41354 PyObject * obj3 = 0 ;
41355 PyObject * obj4 = 0 ;
41356 PyObject * obj5 = 0 ;
41357 char *kwnames[] = {
41358 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41359 };
41360
41361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41363 if (SWIG_arg_fail(1)) SWIG_fail;
41364 {
41365 arg2 = &temp2;
41366 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41367 }
41368 {
41369 arg3 = &temp3;
41370 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41371 }
41372 {
41373 arg4 = (int)(SWIG_As_int(obj3));
41374 if (SWIG_arg_fail(4)) SWIG_fail;
41375 }
41376 {
41377 arg5 = (int)(SWIG_As_int(obj4));
41378 if (SWIG_arg_fail(5)) SWIG_fail;
41379 }
41380 if (obj5) {
41381 arg6 = obj5;
41382 }
41383 {
41384 PyThreadState* __tstate = wxPyBeginAllowThreads();
41385 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41386
41387 wxPyEndAllowThreads(__tstate);
41388 if (PyErr_Occurred()) SWIG_fail;
41389 }
41390 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41391 return resultobj;
41392 fail:
41393 return NULL;
41394 }
41395
41396
41397 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41398 PyObject *resultobj;
41399 wxSizer *arg1 = (wxSizer *) 0 ;
41400 wxGBPosition *arg2 = 0 ;
41401 wxGBSpan *arg3 = 0 ;
41402 int arg4 ;
41403 int arg5 ;
41404 PyObject *arg6 = (PyObject *) NULL ;
41405 wxGBSizerItem *result;
41406 wxGBPosition temp2 ;
41407 wxGBSpan temp3 ;
41408 PyObject * obj0 = 0 ;
41409 PyObject * obj1 = 0 ;
41410 PyObject * obj2 = 0 ;
41411 PyObject * obj3 = 0 ;
41412 PyObject * obj4 = 0 ;
41413 PyObject * obj5 = 0 ;
41414 char *kwnames[] = {
41415 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41416 };
41417
41418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41420 if (SWIG_arg_fail(1)) SWIG_fail;
41421 {
41422 arg2 = &temp2;
41423 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41424 }
41425 {
41426 arg3 = &temp3;
41427 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41428 }
41429 {
41430 arg4 = (int)(SWIG_As_int(obj3));
41431 if (SWIG_arg_fail(4)) SWIG_fail;
41432 }
41433 {
41434 arg5 = (int)(SWIG_As_int(obj4));
41435 if (SWIG_arg_fail(5)) SWIG_fail;
41436 }
41437 if (obj5) {
41438 arg6 = obj5;
41439 }
41440 {
41441 PyThreadState* __tstate = wxPyBeginAllowThreads();
41442 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41443
41444 wxPyEndAllowThreads(__tstate);
41445 if (PyErr_Occurred()) SWIG_fail;
41446 }
41447 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41448 return resultobj;
41449 fail:
41450 return NULL;
41451 }
41452
41453
41454 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
41455 PyObject *resultobj;
41456 int arg1 ;
41457 int arg2 ;
41458 wxGBPosition *arg3 = 0 ;
41459 wxGBSpan *arg4 = 0 ;
41460 int arg5 ;
41461 int arg6 ;
41462 PyObject *arg7 = (PyObject *) NULL ;
41463 wxGBSizerItem *result;
41464 wxGBPosition temp3 ;
41465 wxGBSpan temp4 ;
41466 PyObject * obj0 = 0 ;
41467 PyObject * obj1 = 0 ;
41468 PyObject * obj2 = 0 ;
41469 PyObject * obj3 = 0 ;
41470 PyObject * obj4 = 0 ;
41471 PyObject * obj5 = 0 ;
41472 PyObject * obj6 = 0 ;
41473 char *kwnames[] = {
41474 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41475 };
41476
41477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41478 {
41479 arg1 = (int)(SWIG_As_int(obj0));
41480 if (SWIG_arg_fail(1)) SWIG_fail;
41481 }
41482 {
41483 arg2 = (int)(SWIG_As_int(obj1));
41484 if (SWIG_arg_fail(2)) SWIG_fail;
41485 }
41486 {
41487 arg3 = &temp3;
41488 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41489 }
41490 {
41491 arg4 = &temp4;
41492 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
41493 }
41494 {
41495 arg5 = (int)(SWIG_As_int(obj4));
41496 if (SWIG_arg_fail(5)) SWIG_fail;
41497 }
41498 {
41499 arg6 = (int)(SWIG_As_int(obj5));
41500 if (SWIG_arg_fail(6)) SWIG_fail;
41501 }
41502 if (obj6) {
41503 arg7 = obj6;
41504 }
41505 {
41506 PyThreadState* __tstate = wxPyBeginAllowThreads();
41507 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
41508
41509 wxPyEndAllowThreads(__tstate);
41510 if (PyErr_Occurred()) SWIG_fail;
41511 }
41512 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41513 return resultobj;
41514 fail:
41515 return NULL;
41516 }
41517
41518
41519 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
41520 PyObject *resultobj;
41521 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41522 wxGBPosition result;
41523 PyObject * obj0 = 0 ;
41524 char *kwnames[] = {
41525 (char *) "self", NULL
41526 };
41527
41528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
41529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41530 if (SWIG_arg_fail(1)) SWIG_fail;
41531 {
41532 PyThreadState* __tstate = wxPyBeginAllowThreads();
41533 result = ((wxGBSizerItem const *)arg1)->GetPos();
41534
41535 wxPyEndAllowThreads(__tstate);
41536 if (PyErr_Occurred()) SWIG_fail;
41537 }
41538 {
41539 wxGBPosition * resultptr;
41540 resultptr = new wxGBPosition((wxGBPosition &)(result));
41541 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41542 }
41543 return resultobj;
41544 fail:
41545 return NULL;
41546 }
41547
41548
41549 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41550 PyObject *resultobj;
41551 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41552 wxGBSpan result;
41553 PyObject * obj0 = 0 ;
41554 char *kwnames[] = {
41555 (char *) "self", NULL
41556 };
41557
41558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
41559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41560 if (SWIG_arg_fail(1)) SWIG_fail;
41561 {
41562 PyThreadState* __tstate = wxPyBeginAllowThreads();
41563 result = ((wxGBSizerItem const *)arg1)->GetSpan();
41564
41565 wxPyEndAllowThreads(__tstate);
41566 if (PyErr_Occurred()) SWIG_fail;
41567 }
41568 {
41569 wxGBSpan * resultptr;
41570 resultptr = new wxGBSpan((wxGBSpan &)(result));
41571 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
41572 }
41573 return resultobj;
41574 fail:
41575 return NULL;
41576 }
41577
41578
41579 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
41580 PyObject *resultobj;
41581 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41582 wxGBPosition *arg2 = 0 ;
41583 bool result;
41584 wxGBPosition temp2 ;
41585 PyObject * obj0 = 0 ;
41586 PyObject * obj1 = 0 ;
41587 char *kwnames[] = {
41588 (char *) "self",(char *) "pos", NULL
41589 };
41590
41591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
41592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41593 if (SWIG_arg_fail(1)) SWIG_fail;
41594 {
41595 arg2 = &temp2;
41596 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41597 }
41598 {
41599 PyThreadState* __tstate = wxPyBeginAllowThreads();
41600 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
41601
41602 wxPyEndAllowThreads(__tstate);
41603 if (PyErr_Occurred()) SWIG_fail;
41604 }
41605 {
41606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41607 }
41608 return resultobj;
41609 fail:
41610 return NULL;
41611 }
41612
41613
41614 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41615 PyObject *resultobj;
41616 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41617 wxGBSpan *arg2 = 0 ;
41618 bool result;
41619 wxGBSpan temp2 ;
41620 PyObject * obj0 = 0 ;
41621 PyObject * obj1 = 0 ;
41622 char *kwnames[] = {
41623 (char *) "self",(char *) "span", NULL
41624 };
41625
41626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
41627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41628 if (SWIG_arg_fail(1)) SWIG_fail;
41629 {
41630 arg2 = &temp2;
41631 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41632 }
41633 {
41634 PyThreadState* __tstate = wxPyBeginAllowThreads();
41635 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
41636
41637 wxPyEndAllowThreads(__tstate);
41638 if (PyErr_Occurred()) SWIG_fail;
41639 }
41640 {
41641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41642 }
41643 return resultobj;
41644 fail:
41645 return NULL;
41646 }
41647
41648
41649 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
41650 PyObject *resultobj;
41651 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41652 wxGBSizerItem *arg2 = 0 ;
41653 bool result;
41654 PyObject * obj0 = 0 ;
41655 PyObject * obj1 = 0 ;
41656 char *kwnames[] = {
41657 (char *) "self",(char *) "other", NULL
41658 };
41659
41660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
41661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41662 if (SWIG_arg_fail(1)) SWIG_fail;
41663 {
41664 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41665 if (SWIG_arg_fail(2)) SWIG_fail;
41666 if (arg2 == NULL) {
41667 SWIG_null_ref("wxGBSizerItem");
41668 }
41669 if (SWIG_arg_fail(2)) SWIG_fail;
41670 }
41671 {
41672 PyThreadState* __tstate = wxPyBeginAllowThreads();
41673 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
41674
41675 wxPyEndAllowThreads(__tstate);
41676 if (PyErr_Occurred()) SWIG_fail;
41677 }
41678 {
41679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41680 }
41681 return resultobj;
41682 fail:
41683 return NULL;
41684 }
41685
41686
41687 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
41688 PyObject *resultobj;
41689 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41690 wxGBPosition *arg2 = 0 ;
41691 wxGBSpan *arg3 = 0 ;
41692 bool result;
41693 wxGBPosition temp2 ;
41694 wxGBSpan temp3 ;
41695 PyObject * obj0 = 0 ;
41696 PyObject * obj1 = 0 ;
41697 PyObject * obj2 = 0 ;
41698 char *kwnames[] = {
41699 (char *) "self",(char *) "pos",(char *) "span", NULL
41700 };
41701
41702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
41703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41704 if (SWIG_arg_fail(1)) SWIG_fail;
41705 {
41706 arg2 = &temp2;
41707 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41708 }
41709 {
41710 arg3 = &temp3;
41711 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41712 }
41713 {
41714 PyThreadState* __tstate = wxPyBeginAllowThreads();
41715 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
41716
41717 wxPyEndAllowThreads(__tstate);
41718 if (PyErr_Occurred()) SWIG_fail;
41719 }
41720 {
41721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41722 }
41723 return resultobj;
41724 fail:
41725 return NULL;
41726 }
41727
41728
41729 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
41730 PyObject *resultobj;
41731 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41732 wxGBPosition result;
41733 PyObject * obj0 = 0 ;
41734 char *kwnames[] = {
41735 (char *) "self", NULL
41736 };
41737
41738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
41739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41740 if (SWIG_arg_fail(1)) SWIG_fail;
41741 {
41742 PyThreadState* __tstate = wxPyBeginAllowThreads();
41743 result = wxGBSizerItem_GetEndPos(arg1);
41744
41745 wxPyEndAllowThreads(__tstate);
41746 if (PyErr_Occurred()) SWIG_fail;
41747 }
41748 {
41749 wxGBPosition * resultptr;
41750 resultptr = new wxGBPosition((wxGBPosition &)(result));
41751 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41752 }
41753 return resultobj;
41754 fail:
41755 return NULL;
41756 }
41757
41758
41759 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41760 PyObject *resultobj;
41761 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41762 wxGridBagSizer *result;
41763 PyObject * obj0 = 0 ;
41764 char *kwnames[] = {
41765 (char *) "self", NULL
41766 };
41767
41768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
41769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41770 if (SWIG_arg_fail(1)) SWIG_fail;
41771 {
41772 PyThreadState* __tstate = wxPyBeginAllowThreads();
41773 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
41774
41775 wxPyEndAllowThreads(__tstate);
41776 if (PyErr_Occurred()) SWIG_fail;
41777 }
41778 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
41779 return resultobj;
41780 fail:
41781 return NULL;
41782 }
41783
41784
41785 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41786 PyObject *resultobj;
41787 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41788 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
41789 PyObject * obj0 = 0 ;
41790 PyObject * obj1 = 0 ;
41791 char *kwnames[] = {
41792 (char *) "self",(char *) "sizer", NULL
41793 };
41794
41795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
41796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41797 if (SWIG_arg_fail(1)) SWIG_fail;
41798 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41799 if (SWIG_arg_fail(2)) SWIG_fail;
41800 {
41801 PyThreadState* __tstate = wxPyBeginAllowThreads();
41802 (arg1)->SetGBSizer(arg2);
41803
41804 wxPyEndAllowThreads(__tstate);
41805 if (PyErr_Occurred()) SWIG_fail;
41806 }
41807 Py_INCREF(Py_None); resultobj = Py_None;
41808 return resultobj;
41809 fail:
41810 return NULL;
41811 }
41812
41813
41814 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
41815 PyObject *obj;
41816 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41817 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
41818 Py_INCREF(obj);
41819 return Py_BuildValue((char *)"");
41820 }
41821 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41822 PyObject *resultobj;
41823 int arg1 = (int) 0 ;
41824 int arg2 = (int) 0 ;
41825 wxGridBagSizer *result;
41826 PyObject * obj0 = 0 ;
41827 PyObject * obj1 = 0 ;
41828 char *kwnames[] = {
41829 (char *) "vgap",(char *) "hgap", NULL
41830 };
41831
41832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
41833 if (obj0) {
41834 {
41835 arg1 = (int)(SWIG_As_int(obj0));
41836 if (SWIG_arg_fail(1)) SWIG_fail;
41837 }
41838 }
41839 if (obj1) {
41840 {
41841 arg2 = (int)(SWIG_As_int(obj1));
41842 if (SWIG_arg_fail(2)) SWIG_fail;
41843 }
41844 }
41845 {
41846 PyThreadState* __tstate = wxPyBeginAllowThreads();
41847 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
41848
41849 wxPyEndAllowThreads(__tstate);
41850 if (PyErr_Occurred()) SWIG_fail;
41851 }
41852 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
41853 return resultobj;
41854 fail:
41855 return NULL;
41856 }
41857
41858
41859 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
41860 PyObject *resultobj;
41861 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41862 PyObject *arg2 = (PyObject *) 0 ;
41863 wxGBPosition *arg3 = 0 ;
41864 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
41865 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
41866 int arg5 = (int) 0 ;
41867 int arg6 = (int) 0 ;
41868 PyObject *arg7 = (PyObject *) NULL ;
41869 wxGBSizerItem *result;
41870 wxGBPosition temp3 ;
41871 wxGBSpan temp4 ;
41872 PyObject * obj0 = 0 ;
41873 PyObject * obj1 = 0 ;
41874 PyObject * obj2 = 0 ;
41875 PyObject * obj3 = 0 ;
41876 PyObject * obj4 = 0 ;
41877 PyObject * obj5 = 0 ;
41878 PyObject * obj6 = 0 ;
41879 char *kwnames[] = {
41880 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41881 };
41882
41883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41885 if (SWIG_arg_fail(1)) SWIG_fail;
41886 arg2 = obj1;
41887 {
41888 arg3 = &temp3;
41889 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41890 }
41891 if (obj3) {
41892 {
41893 arg4 = &temp4;
41894 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
41895 }
41896 }
41897 if (obj4) {
41898 {
41899 arg5 = (int)(SWIG_As_int(obj4));
41900 if (SWIG_arg_fail(5)) SWIG_fail;
41901 }
41902 }
41903 if (obj5) {
41904 {
41905 arg6 = (int)(SWIG_As_int(obj5));
41906 if (SWIG_arg_fail(6)) SWIG_fail;
41907 }
41908 }
41909 if (obj6) {
41910 arg7 = obj6;
41911 }
41912 {
41913 PyThreadState* __tstate = wxPyBeginAllowThreads();
41914 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
41915
41916 wxPyEndAllowThreads(__tstate);
41917 if (PyErr_Occurred()) SWIG_fail;
41918 }
41919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
41920 return resultobj;
41921 fail:
41922 return NULL;
41923 }
41924
41925
41926 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
41927 PyObject *resultobj;
41928 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41929 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
41930 wxGBSizerItem *result;
41931 PyObject * obj0 = 0 ;
41932 PyObject * obj1 = 0 ;
41933 char *kwnames[] = {
41934 (char *) "self",(char *) "item", NULL
41935 };
41936
41937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
41938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41939 if (SWIG_arg_fail(1)) SWIG_fail;
41940 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41941 if (SWIG_arg_fail(2)) SWIG_fail;
41942 {
41943 PyThreadState* __tstate = wxPyBeginAllowThreads();
41944 result = (wxGBSizerItem *)(arg1)->Add(arg2);
41945
41946 wxPyEndAllowThreads(__tstate);
41947 if (PyErr_Occurred()) SWIG_fail;
41948 }
41949 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
41950 return resultobj;
41951 fail:
41952 return NULL;
41953 }
41954
41955
41956 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41957 PyObject *resultobj;
41958 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41959 int arg2 ;
41960 int arg3 ;
41961 wxSize result;
41962 PyObject * obj0 = 0 ;
41963 PyObject * obj1 = 0 ;
41964 PyObject * obj2 = 0 ;
41965 char *kwnames[] = {
41966 (char *) "self",(char *) "row",(char *) "col", NULL
41967 };
41968
41969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
41970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41971 if (SWIG_arg_fail(1)) SWIG_fail;
41972 {
41973 arg2 = (int)(SWIG_As_int(obj1));
41974 if (SWIG_arg_fail(2)) SWIG_fail;
41975 }
41976 {
41977 arg3 = (int)(SWIG_As_int(obj2));
41978 if (SWIG_arg_fail(3)) SWIG_fail;
41979 }
41980 {
41981 PyThreadState* __tstate = wxPyBeginAllowThreads();
41982 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
41983
41984 wxPyEndAllowThreads(__tstate);
41985 if (PyErr_Occurred()) SWIG_fail;
41986 }
41987 {
41988 wxSize * resultptr;
41989 resultptr = new wxSize((wxSize &)(result));
41990 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41991 }
41992 return resultobj;
41993 fail:
41994 return NULL;
41995 }
41996
41997
41998 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41999 PyObject *resultobj;
42000 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42001 wxSize result;
42002 PyObject * obj0 = 0 ;
42003 char *kwnames[] = {
42004 (char *) "self", NULL
42005 };
42006
42007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
42008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42009 if (SWIG_arg_fail(1)) SWIG_fail;
42010 {
42011 PyThreadState* __tstate = wxPyBeginAllowThreads();
42012 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
42013
42014 wxPyEndAllowThreads(__tstate);
42015 if (PyErr_Occurred()) SWIG_fail;
42016 }
42017 {
42018 wxSize * resultptr;
42019 resultptr = new wxSize((wxSize &)(result));
42020 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42021 }
42022 return resultobj;
42023 fail:
42024 return NULL;
42025 }
42026
42027
42028 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42029 PyObject *resultobj;
42030 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42031 wxSize *arg2 = 0 ;
42032 wxSize temp2 ;
42033 PyObject * obj0 = 0 ;
42034 PyObject * obj1 = 0 ;
42035 char *kwnames[] = {
42036 (char *) "self",(char *) "sz", NULL
42037 };
42038
42039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
42040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42041 if (SWIG_arg_fail(1)) SWIG_fail;
42042 {
42043 arg2 = &temp2;
42044 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
42045 }
42046 {
42047 PyThreadState* __tstate = wxPyBeginAllowThreads();
42048 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
42049
42050 wxPyEndAllowThreads(__tstate);
42051 if (PyErr_Occurred()) SWIG_fail;
42052 }
42053 Py_INCREF(Py_None); resultobj = Py_None;
42054 return resultobj;
42055 fail:
42056 return NULL;
42057 }
42058
42059
42060 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42061 PyObject *resultobj;
42062 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42063 wxWindow *arg2 = (wxWindow *) 0 ;
42064 wxGBPosition result;
42065 PyObject * obj0 = 0 ;
42066 PyObject * obj1 = 0 ;
42067
42068 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42070 if (SWIG_arg_fail(1)) SWIG_fail;
42071 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42072 if (SWIG_arg_fail(2)) SWIG_fail;
42073 {
42074 PyThreadState* __tstate = wxPyBeginAllowThreads();
42075 result = (arg1)->GetItemPosition(arg2);
42076
42077 wxPyEndAllowThreads(__tstate);
42078 if (PyErr_Occurred()) SWIG_fail;
42079 }
42080 {
42081 wxGBPosition * resultptr;
42082 resultptr = new wxGBPosition((wxGBPosition &)(result));
42083 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42084 }
42085 return resultobj;
42086 fail:
42087 return NULL;
42088 }
42089
42090
42091 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42092 PyObject *resultobj;
42093 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42094 wxSizer *arg2 = (wxSizer *) 0 ;
42095 wxGBPosition result;
42096 PyObject * obj0 = 0 ;
42097 PyObject * obj1 = 0 ;
42098
42099 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42101 if (SWIG_arg_fail(1)) SWIG_fail;
42102 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42103 if (SWIG_arg_fail(2)) SWIG_fail;
42104 {
42105 PyThreadState* __tstate = wxPyBeginAllowThreads();
42106 result = (arg1)->GetItemPosition(arg2);
42107
42108 wxPyEndAllowThreads(__tstate);
42109 if (PyErr_Occurred()) SWIG_fail;
42110 }
42111 {
42112 wxGBPosition * resultptr;
42113 resultptr = new wxGBPosition((wxGBPosition &)(result));
42114 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42115 }
42116 return resultobj;
42117 fail:
42118 return NULL;
42119 }
42120
42121
42122 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42123 PyObject *resultobj;
42124 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42125 size_t arg2 ;
42126 wxGBPosition result;
42127 PyObject * obj0 = 0 ;
42128 PyObject * obj1 = 0 ;
42129
42130 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42132 if (SWIG_arg_fail(1)) SWIG_fail;
42133 {
42134 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42135 if (SWIG_arg_fail(2)) SWIG_fail;
42136 }
42137 {
42138 PyThreadState* __tstate = wxPyBeginAllowThreads();
42139 result = (arg1)->GetItemPosition(arg2);
42140
42141 wxPyEndAllowThreads(__tstate);
42142 if (PyErr_Occurred()) SWIG_fail;
42143 }
42144 {
42145 wxGBPosition * resultptr;
42146 resultptr = new wxGBPosition((wxGBPosition &)(result));
42147 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42148 }
42149 return resultobj;
42150 fail:
42151 return NULL;
42152 }
42153
42154
42155 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
42156 int argc;
42157 PyObject *argv[3];
42158 int ii;
42159
42160 argc = PyObject_Length(args);
42161 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42162 argv[ii] = PyTuple_GetItem(args,ii);
42163 }
42164 if (argc == 2) {
42165 int _v;
42166 {
42167 void *ptr;
42168 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42169 _v = 0;
42170 PyErr_Clear();
42171 } else {
42172 _v = 1;
42173 }
42174 }
42175 if (_v) {
42176 {
42177 void *ptr;
42178 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42179 _v = 0;
42180 PyErr_Clear();
42181 } else {
42182 _v = 1;
42183 }
42184 }
42185 if (_v) {
42186 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
42187 }
42188 }
42189 }
42190 if (argc == 2) {
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 {
42203 void *ptr;
42204 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42205 _v = 0;
42206 PyErr_Clear();
42207 } else {
42208 _v = 1;
42209 }
42210 }
42211 if (_v) {
42212 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
42213 }
42214 }
42215 }
42216 if (argc == 2) {
42217 int _v;
42218 {
42219 void *ptr;
42220 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42221 _v = 0;
42222 PyErr_Clear();
42223 } else {
42224 _v = 1;
42225 }
42226 }
42227 if (_v) {
42228 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42229 if (_v) {
42230 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
42231 }
42232 }
42233 }
42234
42235 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
42236 return NULL;
42237 }
42238
42239
42240 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42241 PyObject *resultobj;
42242 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42243 wxWindow *arg2 = (wxWindow *) 0 ;
42244 wxGBPosition *arg3 = 0 ;
42245 bool result;
42246 wxGBPosition temp3 ;
42247 PyObject * obj0 = 0 ;
42248 PyObject * obj1 = 0 ;
42249 PyObject * obj2 = 0 ;
42250
42251 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42253 if (SWIG_arg_fail(1)) SWIG_fail;
42254 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42255 if (SWIG_arg_fail(2)) SWIG_fail;
42256 {
42257 arg3 = &temp3;
42258 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42259 }
42260 {
42261 PyThreadState* __tstate = wxPyBeginAllowThreads();
42262 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42263
42264 wxPyEndAllowThreads(__tstate);
42265 if (PyErr_Occurred()) SWIG_fail;
42266 }
42267 {
42268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42269 }
42270 return resultobj;
42271 fail:
42272 return NULL;
42273 }
42274
42275
42276 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42277 PyObject *resultobj;
42278 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42279 wxSizer *arg2 = (wxSizer *) 0 ;
42280 wxGBPosition *arg3 = 0 ;
42281 bool result;
42282 wxGBPosition temp3 ;
42283 PyObject * obj0 = 0 ;
42284 PyObject * obj1 = 0 ;
42285 PyObject * obj2 = 0 ;
42286
42287 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42289 if (SWIG_arg_fail(1)) SWIG_fail;
42290 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42291 if (SWIG_arg_fail(2)) SWIG_fail;
42292 {
42293 arg3 = &temp3;
42294 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42295 }
42296 {
42297 PyThreadState* __tstate = wxPyBeginAllowThreads();
42298 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42299
42300 wxPyEndAllowThreads(__tstate);
42301 if (PyErr_Occurred()) SWIG_fail;
42302 }
42303 {
42304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42305 }
42306 return resultobj;
42307 fail:
42308 return NULL;
42309 }
42310
42311
42312 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42313 PyObject *resultobj;
42314 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42315 size_t arg2 ;
42316 wxGBPosition *arg3 = 0 ;
42317 bool result;
42318 wxGBPosition temp3 ;
42319 PyObject * obj0 = 0 ;
42320 PyObject * obj1 = 0 ;
42321 PyObject * obj2 = 0 ;
42322
42323 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42325 if (SWIG_arg_fail(1)) SWIG_fail;
42326 {
42327 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42328 if (SWIG_arg_fail(2)) SWIG_fail;
42329 }
42330 {
42331 arg3 = &temp3;
42332 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42333 }
42334 {
42335 PyThreadState* __tstate = wxPyBeginAllowThreads();
42336 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42337
42338 wxPyEndAllowThreads(__tstate);
42339 if (PyErr_Occurred()) SWIG_fail;
42340 }
42341 {
42342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42343 }
42344 return resultobj;
42345 fail:
42346 return NULL;
42347 }
42348
42349
42350 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
42351 int argc;
42352 PyObject *argv[4];
42353 int ii;
42354
42355 argc = PyObject_Length(args);
42356 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42357 argv[ii] = PyTuple_GetItem(args,ii);
42358 }
42359 if (argc == 3) {
42360 int _v;
42361 {
42362 void *ptr;
42363 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42364 _v = 0;
42365 PyErr_Clear();
42366 } else {
42367 _v = 1;
42368 }
42369 }
42370 if (_v) {
42371 {
42372 void *ptr;
42373 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42374 _v = 0;
42375 PyErr_Clear();
42376 } else {
42377 _v = 1;
42378 }
42379 }
42380 if (_v) {
42381 {
42382 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42383 }
42384 if (_v) {
42385 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
42386 }
42387 }
42388 }
42389 }
42390 if (argc == 3) {
42391 int _v;
42392 {
42393 void *ptr;
42394 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42395 _v = 0;
42396 PyErr_Clear();
42397 } else {
42398 _v = 1;
42399 }
42400 }
42401 if (_v) {
42402 {
42403 void *ptr;
42404 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42405 _v = 0;
42406 PyErr_Clear();
42407 } else {
42408 _v = 1;
42409 }
42410 }
42411 if (_v) {
42412 {
42413 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42414 }
42415 if (_v) {
42416 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
42417 }
42418 }
42419 }
42420 }
42421 if (argc == 3) {
42422 int _v;
42423 {
42424 void *ptr;
42425 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42426 _v = 0;
42427 PyErr_Clear();
42428 } else {
42429 _v = 1;
42430 }
42431 }
42432 if (_v) {
42433 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42434 if (_v) {
42435 {
42436 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42437 }
42438 if (_v) {
42439 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
42440 }
42441 }
42442 }
42443 }
42444
42445 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
42446 return NULL;
42447 }
42448
42449
42450 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42451 PyObject *resultobj;
42452 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42453 wxWindow *arg2 = (wxWindow *) 0 ;
42454 wxGBSpan result;
42455 PyObject * obj0 = 0 ;
42456 PyObject * obj1 = 0 ;
42457
42458 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42460 if (SWIG_arg_fail(1)) SWIG_fail;
42461 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42462 if (SWIG_arg_fail(2)) SWIG_fail;
42463 {
42464 PyThreadState* __tstate = wxPyBeginAllowThreads();
42465 result = (arg1)->GetItemSpan(arg2);
42466
42467 wxPyEndAllowThreads(__tstate);
42468 if (PyErr_Occurred()) SWIG_fail;
42469 }
42470 {
42471 wxGBSpan * resultptr;
42472 resultptr = new wxGBSpan((wxGBSpan &)(result));
42473 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42474 }
42475 return resultobj;
42476 fail:
42477 return NULL;
42478 }
42479
42480
42481 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42482 PyObject *resultobj;
42483 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42484 wxSizer *arg2 = (wxSizer *) 0 ;
42485 wxGBSpan result;
42486 PyObject * obj0 = 0 ;
42487 PyObject * obj1 = 0 ;
42488
42489 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42491 if (SWIG_arg_fail(1)) SWIG_fail;
42492 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42493 if (SWIG_arg_fail(2)) SWIG_fail;
42494 {
42495 PyThreadState* __tstate = wxPyBeginAllowThreads();
42496 result = (arg1)->GetItemSpan(arg2);
42497
42498 wxPyEndAllowThreads(__tstate);
42499 if (PyErr_Occurred()) SWIG_fail;
42500 }
42501 {
42502 wxGBSpan * resultptr;
42503 resultptr = new wxGBSpan((wxGBSpan &)(result));
42504 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42505 }
42506 return resultobj;
42507 fail:
42508 return NULL;
42509 }
42510
42511
42512 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42513 PyObject *resultobj;
42514 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42515 size_t arg2 ;
42516 wxGBSpan result;
42517 PyObject * obj0 = 0 ;
42518 PyObject * obj1 = 0 ;
42519
42520 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42522 if (SWIG_arg_fail(1)) SWIG_fail;
42523 {
42524 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42525 if (SWIG_arg_fail(2)) SWIG_fail;
42526 }
42527 {
42528 PyThreadState* __tstate = wxPyBeginAllowThreads();
42529 result = (arg1)->GetItemSpan(arg2);
42530
42531 wxPyEndAllowThreads(__tstate);
42532 if (PyErr_Occurred()) SWIG_fail;
42533 }
42534 {
42535 wxGBSpan * resultptr;
42536 resultptr = new wxGBSpan((wxGBSpan &)(result));
42537 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42538 }
42539 return resultobj;
42540 fail:
42541 return NULL;
42542 }
42543
42544
42545 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
42546 int argc;
42547 PyObject *argv[3];
42548 int ii;
42549
42550 argc = PyObject_Length(args);
42551 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42552 argv[ii] = PyTuple_GetItem(args,ii);
42553 }
42554 if (argc == 2) {
42555 int _v;
42556 {
42557 void *ptr;
42558 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42559 _v = 0;
42560 PyErr_Clear();
42561 } else {
42562 _v = 1;
42563 }
42564 }
42565 if (_v) {
42566 {
42567 void *ptr;
42568 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42569 _v = 0;
42570 PyErr_Clear();
42571 } else {
42572 _v = 1;
42573 }
42574 }
42575 if (_v) {
42576 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
42577 }
42578 }
42579 }
42580 if (argc == 2) {
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 {
42593 void *ptr;
42594 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42595 _v = 0;
42596 PyErr_Clear();
42597 } else {
42598 _v = 1;
42599 }
42600 }
42601 if (_v) {
42602 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
42603 }
42604 }
42605 }
42606 if (argc == 2) {
42607 int _v;
42608 {
42609 void *ptr;
42610 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42611 _v = 0;
42612 PyErr_Clear();
42613 } else {
42614 _v = 1;
42615 }
42616 }
42617 if (_v) {
42618 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42619 if (_v) {
42620 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
42621 }
42622 }
42623 }
42624
42625 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
42626 return NULL;
42627 }
42628
42629
42630 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42631 PyObject *resultobj;
42632 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42633 wxWindow *arg2 = (wxWindow *) 0 ;
42634 wxGBSpan *arg3 = 0 ;
42635 bool result;
42636 wxGBSpan temp3 ;
42637 PyObject * obj0 = 0 ;
42638 PyObject * obj1 = 0 ;
42639 PyObject * obj2 = 0 ;
42640
42641 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42643 if (SWIG_arg_fail(1)) SWIG_fail;
42644 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42645 if (SWIG_arg_fail(2)) SWIG_fail;
42646 {
42647 arg3 = &temp3;
42648 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42649 }
42650 {
42651 PyThreadState* __tstate = wxPyBeginAllowThreads();
42652 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42653
42654 wxPyEndAllowThreads(__tstate);
42655 if (PyErr_Occurred()) SWIG_fail;
42656 }
42657 {
42658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42659 }
42660 return resultobj;
42661 fail:
42662 return NULL;
42663 }
42664
42665
42666 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42667 PyObject *resultobj;
42668 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42669 wxSizer *arg2 = (wxSizer *) 0 ;
42670 wxGBSpan *arg3 = 0 ;
42671 bool result;
42672 wxGBSpan temp3 ;
42673 PyObject * obj0 = 0 ;
42674 PyObject * obj1 = 0 ;
42675 PyObject * obj2 = 0 ;
42676
42677 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42679 if (SWIG_arg_fail(1)) SWIG_fail;
42680 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42681 if (SWIG_arg_fail(2)) SWIG_fail;
42682 {
42683 arg3 = &temp3;
42684 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42685 }
42686 {
42687 PyThreadState* __tstate = wxPyBeginAllowThreads();
42688 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42689
42690 wxPyEndAllowThreads(__tstate);
42691 if (PyErr_Occurred()) SWIG_fail;
42692 }
42693 {
42694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42695 }
42696 return resultobj;
42697 fail:
42698 return NULL;
42699 }
42700
42701
42702 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42703 PyObject *resultobj;
42704 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42705 size_t arg2 ;
42706 wxGBSpan *arg3 = 0 ;
42707 bool result;
42708 wxGBSpan temp3 ;
42709 PyObject * obj0 = 0 ;
42710 PyObject * obj1 = 0 ;
42711 PyObject * obj2 = 0 ;
42712
42713 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42715 if (SWIG_arg_fail(1)) SWIG_fail;
42716 {
42717 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42718 if (SWIG_arg_fail(2)) SWIG_fail;
42719 }
42720 {
42721 arg3 = &temp3;
42722 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42723 }
42724 {
42725 PyThreadState* __tstate = wxPyBeginAllowThreads();
42726 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42727
42728 wxPyEndAllowThreads(__tstate);
42729 if (PyErr_Occurred()) SWIG_fail;
42730 }
42731 {
42732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42733 }
42734 return resultobj;
42735 fail:
42736 return NULL;
42737 }
42738
42739
42740 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
42741 int argc;
42742 PyObject *argv[4];
42743 int ii;
42744
42745 argc = PyObject_Length(args);
42746 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42747 argv[ii] = PyTuple_GetItem(args,ii);
42748 }
42749 if (argc == 3) {
42750 int _v;
42751 {
42752 void *ptr;
42753 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42754 _v = 0;
42755 PyErr_Clear();
42756 } else {
42757 _v = 1;
42758 }
42759 }
42760 if (_v) {
42761 {
42762 void *ptr;
42763 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42764 _v = 0;
42765 PyErr_Clear();
42766 } else {
42767 _v = 1;
42768 }
42769 }
42770 if (_v) {
42771 {
42772 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42773 }
42774 if (_v) {
42775 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
42776 }
42777 }
42778 }
42779 }
42780 if (argc == 3) {
42781 int _v;
42782 {
42783 void *ptr;
42784 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42785 _v = 0;
42786 PyErr_Clear();
42787 } else {
42788 _v = 1;
42789 }
42790 }
42791 if (_v) {
42792 {
42793 void *ptr;
42794 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42795 _v = 0;
42796 PyErr_Clear();
42797 } else {
42798 _v = 1;
42799 }
42800 }
42801 if (_v) {
42802 {
42803 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42804 }
42805 if (_v) {
42806 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
42807 }
42808 }
42809 }
42810 }
42811 if (argc == 3) {
42812 int _v;
42813 {
42814 void *ptr;
42815 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42816 _v = 0;
42817 PyErr_Clear();
42818 } else {
42819 _v = 1;
42820 }
42821 }
42822 if (_v) {
42823 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42824 if (_v) {
42825 {
42826 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42827 }
42828 if (_v) {
42829 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
42830 }
42831 }
42832 }
42833 }
42834
42835 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
42836 return NULL;
42837 }
42838
42839
42840 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
42841 PyObject *resultobj;
42842 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42843 wxWindow *arg2 = (wxWindow *) 0 ;
42844 wxGBSizerItem *result;
42845 PyObject * obj0 = 0 ;
42846 PyObject * obj1 = 0 ;
42847
42848 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
42849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42850 if (SWIG_arg_fail(1)) SWIG_fail;
42851 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42852 if (SWIG_arg_fail(2)) SWIG_fail;
42853 {
42854 PyThreadState* __tstate = wxPyBeginAllowThreads();
42855 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
42856
42857 wxPyEndAllowThreads(__tstate);
42858 if (PyErr_Occurred()) SWIG_fail;
42859 }
42860 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42861 return resultobj;
42862 fail:
42863 return NULL;
42864 }
42865
42866
42867 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
42868 PyObject *resultobj;
42869 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42870 wxSizer *arg2 = (wxSizer *) 0 ;
42871 wxGBSizerItem *result;
42872 PyObject * obj0 = 0 ;
42873 PyObject * obj1 = 0 ;
42874
42875 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
42876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42877 if (SWIG_arg_fail(1)) SWIG_fail;
42878 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42879 if (SWIG_arg_fail(2)) SWIG_fail;
42880 {
42881 PyThreadState* __tstate = wxPyBeginAllowThreads();
42882 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
42883
42884 wxPyEndAllowThreads(__tstate);
42885 if (PyErr_Occurred()) SWIG_fail;
42886 }
42887 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42888 return resultobj;
42889 fail:
42890 return NULL;
42891 }
42892
42893
42894 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
42895 int argc;
42896 PyObject *argv[3];
42897 int ii;
42898
42899 argc = PyObject_Length(args);
42900 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42901 argv[ii] = PyTuple_GetItem(args,ii);
42902 }
42903 if (argc == 2) {
42904 int _v;
42905 {
42906 void *ptr;
42907 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42908 _v = 0;
42909 PyErr_Clear();
42910 } else {
42911 _v = 1;
42912 }
42913 }
42914 if (_v) {
42915 {
42916 void *ptr;
42917 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42918 _v = 0;
42919 PyErr_Clear();
42920 } else {
42921 _v = 1;
42922 }
42923 }
42924 if (_v) {
42925 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
42926 }
42927 }
42928 }
42929 if (argc == 2) {
42930 int _v;
42931 {
42932 void *ptr;
42933 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42934 _v = 0;
42935 PyErr_Clear();
42936 } else {
42937 _v = 1;
42938 }
42939 }
42940 if (_v) {
42941 {
42942 void *ptr;
42943 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42944 _v = 0;
42945 PyErr_Clear();
42946 } else {
42947 _v = 1;
42948 }
42949 }
42950 if (_v) {
42951 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
42952 }
42953 }
42954 }
42955
42956 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
42957 return NULL;
42958 }
42959
42960
42961 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42962 PyObject *resultobj;
42963 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42964 wxGBPosition *arg2 = 0 ;
42965 wxGBSizerItem *result;
42966 wxGBPosition temp2 ;
42967 PyObject * obj0 = 0 ;
42968 PyObject * obj1 = 0 ;
42969 char *kwnames[] = {
42970 (char *) "self",(char *) "pos", NULL
42971 };
42972
42973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
42974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42975 if (SWIG_arg_fail(1)) SWIG_fail;
42976 {
42977 arg2 = &temp2;
42978 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42979 }
42980 {
42981 PyThreadState* __tstate = wxPyBeginAllowThreads();
42982 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
42983
42984 wxPyEndAllowThreads(__tstate);
42985 if (PyErr_Occurred()) SWIG_fail;
42986 }
42987 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42988 return resultobj;
42989 fail:
42990 return NULL;
42991 }
42992
42993
42994 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
42995 PyObject *resultobj;
42996 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42997 wxPoint *arg2 = 0 ;
42998 wxGBSizerItem *result;
42999 wxPoint temp2 ;
43000 PyObject * obj0 = 0 ;
43001 PyObject * obj1 = 0 ;
43002 char *kwnames[] = {
43003 (char *) "self",(char *) "pt", NULL
43004 };
43005
43006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
43007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43008 if (SWIG_arg_fail(1)) SWIG_fail;
43009 {
43010 arg2 = &temp2;
43011 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
43012 }
43013 {
43014 PyThreadState* __tstate = wxPyBeginAllowThreads();
43015 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
43016
43017 wxPyEndAllowThreads(__tstate);
43018 if (PyErr_Occurred()) SWIG_fail;
43019 }
43020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43021 return resultobj;
43022 fail:
43023 return NULL;
43024 }
43025
43026
43027 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
43028 PyObject *resultobj;
43029 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43030 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43031 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
43032 bool result;
43033 PyObject * obj0 = 0 ;
43034 PyObject * obj1 = 0 ;
43035 PyObject * obj2 = 0 ;
43036 char *kwnames[] = {
43037 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
43038 };
43039
43040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
43041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43042 if (SWIG_arg_fail(1)) SWIG_fail;
43043 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43044 if (SWIG_arg_fail(2)) SWIG_fail;
43045 if (obj2) {
43046 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43047 if (SWIG_arg_fail(3)) SWIG_fail;
43048 }
43049 {
43050 PyThreadState* __tstate = wxPyBeginAllowThreads();
43051 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
43052
43053 wxPyEndAllowThreads(__tstate);
43054 if (PyErr_Occurred()) SWIG_fail;
43055 }
43056 {
43057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43058 }
43059 return resultobj;
43060 fail:
43061 return NULL;
43062 }
43063
43064
43065 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
43066 PyObject *resultobj;
43067 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43068 wxGBPosition *arg2 = 0 ;
43069 wxGBSpan *arg3 = 0 ;
43070 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
43071 bool result;
43072 wxGBPosition temp2 ;
43073 wxGBSpan temp3 ;
43074 PyObject * obj0 = 0 ;
43075 PyObject * obj1 = 0 ;
43076 PyObject * obj2 = 0 ;
43077 PyObject * obj3 = 0 ;
43078 char *kwnames[] = {
43079 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
43080 };
43081
43082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43084 if (SWIG_arg_fail(1)) SWIG_fail;
43085 {
43086 arg2 = &temp2;
43087 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43088 }
43089 {
43090 arg3 = &temp3;
43091 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43092 }
43093 if (obj3) {
43094 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43095 if (SWIG_arg_fail(4)) SWIG_fail;
43096 }
43097 {
43098 PyThreadState* __tstate = wxPyBeginAllowThreads();
43099 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
43100
43101 wxPyEndAllowThreads(__tstate);
43102 if (PyErr_Occurred()) SWIG_fail;
43103 }
43104 {
43105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43106 }
43107 return resultobj;
43108 fail:
43109 return NULL;
43110 }
43111
43112
43113 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
43114 PyObject *obj;
43115 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43116 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
43117 Py_INCREF(obj);
43118 return Py_BuildValue((char *)"");
43119 }
43120 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43121 PyObject *resultobj;
43122 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43123 wxRelationship arg2 ;
43124 wxWindow *arg3 = (wxWindow *) 0 ;
43125 wxEdge arg4 ;
43126 int arg5 = (int) 0 ;
43127 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
43128 PyObject * obj0 = 0 ;
43129 PyObject * obj1 = 0 ;
43130 PyObject * obj2 = 0 ;
43131 PyObject * obj3 = 0 ;
43132 PyObject * obj4 = 0 ;
43133 PyObject * obj5 = 0 ;
43134 char *kwnames[] = {
43135 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
43136 };
43137
43138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43140 if (SWIG_arg_fail(1)) SWIG_fail;
43141 {
43142 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43143 if (SWIG_arg_fail(2)) SWIG_fail;
43144 }
43145 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43146 if (SWIG_arg_fail(3)) SWIG_fail;
43147 {
43148 arg4 = (wxEdge)(SWIG_As_int(obj3));
43149 if (SWIG_arg_fail(4)) SWIG_fail;
43150 }
43151 if (obj4) {
43152 {
43153 arg5 = (int)(SWIG_As_int(obj4));
43154 if (SWIG_arg_fail(5)) SWIG_fail;
43155 }
43156 }
43157 if (obj5) {
43158 {
43159 arg6 = (int)(SWIG_As_int(obj5));
43160 if (SWIG_arg_fail(6)) SWIG_fail;
43161 }
43162 }
43163 {
43164 PyThreadState* __tstate = wxPyBeginAllowThreads();
43165 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
43166
43167 wxPyEndAllowThreads(__tstate);
43168 if (PyErr_Occurred()) SWIG_fail;
43169 }
43170 Py_INCREF(Py_None); resultobj = Py_None;
43171 return resultobj;
43172 fail:
43173 return NULL;
43174 }
43175
43176
43177 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
43178 PyObject *resultobj;
43179 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43180 wxWindow *arg2 = (wxWindow *) 0 ;
43181 int arg3 = (int) 0 ;
43182 PyObject * obj0 = 0 ;
43183 PyObject * obj1 = 0 ;
43184 PyObject * obj2 = 0 ;
43185 char *kwnames[] = {
43186 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43187 };
43188
43189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43191 if (SWIG_arg_fail(1)) SWIG_fail;
43192 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43193 if (SWIG_arg_fail(2)) SWIG_fail;
43194 if (obj2) {
43195 {
43196 arg3 = (int)(SWIG_As_int(obj2));
43197 if (SWIG_arg_fail(3)) SWIG_fail;
43198 }
43199 }
43200 {
43201 PyThreadState* __tstate = wxPyBeginAllowThreads();
43202 (arg1)->LeftOf(arg2,arg3);
43203
43204 wxPyEndAllowThreads(__tstate);
43205 if (PyErr_Occurred()) SWIG_fail;
43206 }
43207 Py_INCREF(Py_None); resultobj = Py_None;
43208 return resultobj;
43209 fail:
43210 return NULL;
43211 }
43212
43213
43214 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
43215 PyObject *resultobj;
43216 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43217 wxWindow *arg2 = (wxWindow *) 0 ;
43218 int arg3 = (int) 0 ;
43219 PyObject * obj0 = 0 ;
43220 PyObject * obj1 = 0 ;
43221 PyObject * obj2 = 0 ;
43222 char *kwnames[] = {
43223 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43224 };
43225
43226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43228 if (SWIG_arg_fail(1)) SWIG_fail;
43229 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43230 if (SWIG_arg_fail(2)) SWIG_fail;
43231 if (obj2) {
43232 {
43233 arg3 = (int)(SWIG_As_int(obj2));
43234 if (SWIG_arg_fail(3)) SWIG_fail;
43235 }
43236 }
43237 {
43238 PyThreadState* __tstate = wxPyBeginAllowThreads();
43239 (arg1)->RightOf(arg2,arg3);
43240
43241 wxPyEndAllowThreads(__tstate);
43242 if (PyErr_Occurred()) SWIG_fail;
43243 }
43244 Py_INCREF(Py_None); resultobj = Py_None;
43245 return resultobj;
43246 fail:
43247 return NULL;
43248 }
43249
43250
43251 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
43252 PyObject *resultobj;
43253 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43254 wxWindow *arg2 = (wxWindow *) 0 ;
43255 int arg3 = (int) 0 ;
43256 PyObject * obj0 = 0 ;
43257 PyObject * obj1 = 0 ;
43258 PyObject * obj2 = 0 ;
43259 char *kwnames[] = {
43260 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43261 };
43262
43263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
43264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43265 if (SWIG_arg_fail(1)) SWIG_fail;
43266 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43267 if (SWIG_arg_fail(2)) SWIG_fail;
43268 if (obj2) {
43269 {
43270 arg3 = (int)(SWIG_As_int(obj2));
43271 if (SWIG_arg_fail(3)) SWIG_fail;
43272 }
43273 }
43274 {
43275 PyThreadState* __tstate = wxPyBeginAllowThreads();
43276 (arg1)->Above(arg2,arg3);
43277
43278 wxPyEndAllowThreads(__tstate);
43279 if (PyErr_Occurred()) SWIG_fail;
43280 }
43281 Py_INCREF(Py_None); resultobj = Py_None;
43282 return resultobj;
43283 fail:
43284 return NULL;
43285 }
43286
43287
43288 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
43289 PyObject *resultobj;
43290 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43291 wxWindow *arg2 = (wxWindow *) 0 ;
43292 int arg3 = (int) 0 ;
43293 PyObject * obj0 = 0 ;
43294 PyObject * obj1 = 0 ;
43295 PyObject * obj2 = 0 ;
43296 char *kwnames[] = {
43297 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43298 };
43299
43300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
43301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43302 if (SWIG_arg_fail(1)) SWIG_fail;
43303 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43304 if (SWIG_arg_fail(2)) SWIG_fail;
43305 if (obj2) {
43306 {
43307 arg3 = (int)(SWIG_As_int(obj2));
43308 if (SWIG_arg_fail(3)) SWIG_fail;
43309 }
43310 }
43311 {
43312 PyThreadState* __tstate = wxPyBeginAllowThreads();
43313 (arg1)->Below(arg2,arg3);
43314
43315 wxPyEndAllowThreads(__tstate);
43316 if (PyErr_Occurred()) SWIG_fail;
43317 }
43318 Py_INCREF(Py_None); resultobj = Py_None;
43319 return resultobj;
43320 fail:
43321 return NULL;
43322 }
43323
43324
43325 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
43326 PyObject *resultobj;
43327 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43328 wxWindow *arg2 = (wxWindow *) 0 ;
43329 wxEdge arg3 ;
43330 int arg4 = (int) 0 ;
43331 PyObject * obj0 = 0 ;
43332 PyObject * obj1 = 0 ;
43333 PyObject * obj2 = 0 ;
43334 PyObject * obj3 = 0 ;
43335 char *kwnames[] = {
43336 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
43337 };
43338
43339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43341 if (SWIG_arg_fail(1)) SWIG_fail;
43342 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43343 if (SWIG_arg_fail(2)) SWIG_fail;
43344 {
43345 arg3 = (wxEdge)(SWIG_As_int(obj2));
43346 if (SWIG_arg_fail(3)) SWIG_fail;
43347 }
43348 if (obj3) {
43349 {
43350 arg4 = (int)(SWIG_As_int(obj3));
43351 if (SWIG_arg_fail(4)) SWIG_fail;
43352 }
43353 }
43354 {
43355 PyThreadState* __tstate = wxPyBeginAllowThreads();
43356 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
43357
43358 wxPyEndAllowThreads(__tstate);
43359 if (PyErr_Occurred()) SWIG_fail;
43360 }
43361 Py_INCREF(Py_None); resultobj = Py_None;
43362 return resultobj;
43363 fail:
43364 return NULL;
43365 }
43366
43367
43368 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
43369 PyObject *resultobj;
43370 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43371 wxWindow *arg2 = (wxWindow *) 0 ;
43372 wxEdge arg3 ;
43373 int arg4 ;
43374 PyObject * obj0 = 0 ;
43375 PyObject * obj1 = 0 ;
43376 PyObject * obj2 = 0 ;
43377 PyObject * obj3 = 0 ;
43378 char *kwnames[] = {
43379 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
43380 };
43381
43382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43384 if (SWIG_arg_fail(1)) SWIG_fail;
43385 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43386 if (SWIG_arg_fail(2)) SWIG_fail;
43387 {
43388 arg3 = (wxEdge)(SWIG_As_int(obj2));
43389 if (SWIG_arg_fail(3)) SWIG_fail;
43390 }
43391 {
43392 arg4 = (int)(SWIG_As_int(obj3));
43393 if (SWIG_arg_fail(4)) SWIG_fail;
43394 }
43395 {
43396 PyThreadState* __tstate = wxPyBeginAllowThreads();
43397 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
43398
43399 wxPyEndAllowThreads(__tstate);
43400 if (PyErr_Occurred()) SWIG_fail;
43401 }
43402 Py_INCREF(Py_None); resultobj = Py_None;
43403 return resultobj;
43404 fail:
43405 return NULL;
43406 }
43407
43408
43409 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
43410 PyObject *resultobj;
43411 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43412 int arg2 ;
43413 PyObject * obj0 = 0 ;
43414 PyObject * obj1 = 0 ;
43415 char *kwnames[] = {
43416 (char *) "self",(char *) "val", NULL
43417 };
43418
43419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
43420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43421 if (SWIG_arg_fail(1)) SWIG_fail;
43422 {
43423 arg2 = (int)(SWIG_As_int(obj1));
43424 if (SWIG_arg_fail(2)) SWIG_fail;
43425 }
43426 {
43427 PyThreadState* __tstate = wxPyBeginAllowThreads();
43428 (arg1)->Absolute(arg2);
43429
43430 wxPyEndAllowThreads(__tstate);
43431 if (PyErr_Occurred()) SWIG_fail;
43432 }
43433 Py_INCREF(Py_None); resultobj = Py_None;
43434 return resultobj;
43435 fail:
43436 return NULL;
43437 }
43438
43439
43440 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
43441 PyObject *resultobj;
43442 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43443 PyObject * obj0 = 0 ;
43444 char *kwnames[] = {
43445 (char *) "self", NULL
43446 };
43447
43448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
43449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43450 if (SWIG_arg_fail(1)) SWIG_fail;
43451 {
43452 PyThreadState* __tstate = wxPyBeginAllowThreads();
43453 (arg1)->Unconstrained();
43454
43455 wxPyEndAllowThreads(__tstate);
43456 if (PyErr_Occurred()) SWIG_fail;
43457 }
43458 Py_INCREF(Py_None); resultobj = Py_None;
43459 return resultobj;
43460 fail:
43461 return NULL;
43462 }
43463
43464
43465 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
43466 PyObject *resultobj;
43467 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43468 PyObject * obj0 = 0 ;
43469 char *kwnames[] = {
43470 (char *) "self", NULL
43471 };
43472
43473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
43474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43475 if (SWIG_arg_fail(1)) SWIG_fail;
43476 {
43477 PyThreadState* __tstate = wxPyBeginAllowThreads();
43478 (arg1)->AsIs();
43479
43480 wxPyEndAllowThreads(__tstate);
43481 if (PyErr_Occurred()) SWIG_fail;
43482 }
43483 Py_INCREF(Py_None); resultobj = Py_None;
43484 return resultobj;
43485 fail:
43486 return NULL;
43487 }
43488
43489
43490 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43491 PyObject *resultobj;
43492 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43493 wxWindow *result;
43494 PyObject * obj0 = 0 ;
43495 char *kwnames[] = {
43496 (char *) "self", NULL
43497 };
43498
43499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",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 = (wxWindow *)(arg1)->GetOtherWindow();
43505
43506 wxPyEndAllowThreads(__tstate);
43507 if (PyErr_Occurred()) SWIG_fail;
43508 }
43509 {
43510 resultobj = wxPyMake_wxObject(result, 0);
43511 }
43512 return resultobj;
43513 fail:
43514 return NULL;
43515 }
43516
43517
43518 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43519 PyObject *resultobj;
43520 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43521 wxEdge result;
43522 PyObject * obj0 = 0 ;
43523 char *kwnames[] = {
43524 (char *) "self", NULL
43525 };
43526
43527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",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 = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
43533
43534 wxPyEndAllowThreads(__tstate);
43535 if (PyErr_Occurred()) SWIG_fail;
43536 }
43537 resultobj = SWIG_From_int((result));
43538 return resultobj;
43539 fail:
43540 return NULL;
43541 }
43542
43543
43544 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43545 PyObject *resultobj;
43546 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43547 wxEdge arg2 ;
43548 PyObject * obj0 = 0 ;
43549 PyObject * obj1 = 0 ;
43550 char *kwnames[] = {
43551 (char *) "self",(char *) "which", NULL
43552 };
43553
43554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
43555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43556 if (SWIG_arg_fail(1)) SWIG_fail;
43557 {
43558 arg2 = (wxEdge)(SWIG_As_int(obj1));
43559 if (SWIG_arg_fail(2)) SWIG_fail;
43560 }
43561 {
43562 PyThreadState* __tstate = wxPyBeginAllowThreads();
43563 (arg1)->SetEdge((wxEdge )arg2);
43564
43565 wxPyEndAllowThreads(__tstate);
43566 if (PyErr_Occurred()) SWIG_fail;
43567 }
43568 Py_INCREF(Py_None); resultobj = Py_None;
43569 return resultobj;
43570 fail:
43571 return NULL;
43572 }
43573
43574
43575 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
43576 PyObject *resultobj;
43577 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43578 int arg2 ;
43579 PyObject * obj0 = 0 ;
43580 PyObject * obj1 = 0 ;
43581 char *kwnames[] = {
43582 (char *) "self",(char *) "v", NULL
43583 };
43584
43585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
43586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43587 if (SWIG_arg_fail(1)) SWIG_fail;
43588 {
43589 arg2 = (int)(SWIG_As_int(obj1));
43590 if (SWIG_arg_fail(2)) SWIG_fail;
43591 }
43592 {
43593 PyThreadState* __tstate = wxPyBeginAllowThreads();
43594 (arg1)->SetValue(arg2);
43595
43596 wxPyEndAllowThreads(__tstate);
43597 if (PyErr_Occurred()) SWIG_fail;
43598 }
43599 Py_INCREF(Py_None); resultobj = Py_None;
43600 return resultobj;
43601 fail:
43602 return NULL;
43603 }
43604
43605
43606 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
43607 PyObject *resultobj;
43608 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43609 int result;
43610 PyObject * obj0 = 0 ;
43611 char *kwnames[] = {
43612 (char *) "self", NULL
43613 };
43614
43615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
43616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43617 if (SWIG_arg_fail(1)) SWIG_fail;
43618 {
43619 PyThreadState* __tstate = wxPyBeginAllowThreads();
43620 result = (int)(arg1)->GetMargin();
43621
43622 wxPyEndAllowThreads(__tstate);
43623 if (PyErr_Occurred()) SWIG_fail;
43624 }
43625 {
43626 resultobj = SWIG_From_int((int)(result));
43627 }
43628 return resultobj;
43629 fail:
43630 return NULL;
43631 }
43632
43633
43634 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
43635 PyObject *resultobj;
43636 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43637 int arg2 ;
43638 PyObject * obj0 = 0 ;
43639 PyObject * obj1 = 0 ;
43640 char *kwnames[] = {
43641 (char *) "self",(char *) "m", NULL
43642 };
43643
43644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
43645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43646 if (SWIG_arg_fail(1)) SWIG_fail;
43647 {
43648 arg2 = (int)(SWIG_As_int(obj1));
43649 if (SWIG_arg_fail(2)) SWIG_fail;
43650 }
43651 {
43652 PyThreadState* __tstate = wxPyBeginAllowThreads();
43653 (arg1)->SetMargin(arg2);
43654
43655 wxPyEndAllowThreads(__tstate);
43656 if (PyErr_Occurred()) SWIG_fail;
43657 }
43658 Py_INCREF(Py_None); resultobj = Py_None;
43659 return resultobj;
43660 fail:
43661 return NULL;
43662 }
43663
43664
43665 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
43666 PyObject *resultobj;
43667 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43668 int result;
43669 PyObject * obj0 = 0 ;
43670 char *kwnames[] = {
43671 (char *) "self", NULL
43672 };
43673
43674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
43675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43676 if (SWIG_arg_fail(1)) SWIG_fail;
43677 {
43678 PyThreadState* __tstate = wxPyBeginAllowThreads();
43679 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
43680
43681 wxPyEndAllowThreads(__tstate);
43682 if (PyErr_Occurred()) SWIG_fail;
43683 }
43684 {
43685 resultobj = SWIG_From_int((int)(result));
43686 }
43687 return resultobj;
43688 fail:
43689 return NULL;
43690 }
43691
43692
43693 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
43694 PyObject *resultobj;
43695 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43696 int result;
43697 PyObject * obj0 = 0 ;
43698 char *kwnames[] = {
43699 (char *) "self", NULL
43700 };
43701
43702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
43703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43704 if (SWIG_arg_fail(1)) SWIG_fail;
43705 {
43706 PyThreadState* __tstate = wxPyBeginAllowThreads();
43707 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
43708
43709 wxPyEndAllowThreads(__tstate);
43710 if (PyErr_Occurred()) SWIG_fail;
43711 }
43712 {
43713 resultobj = SWIG_From_int((int)(result));
43714 }
43715 return resultobj;
43716 fail:
43717 return NULL;
43718 }
43719
43720
43721 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43722 PyObject *resultobj;
43723 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43724 int result;
43725 PyObject * obj0 = 0 ;
43726 char *kwnames[] = {
43727 (char *) "self", NULL
43728 };
43729
43730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
43731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43732 if (SWIG_arg_fail(1)) SWIG_fail;
43733 {
43734 PyThreadState* __tstate = wxPyBeginAllowThreads();
43735 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
43736
43737 wxPyEndAllowThreads(__tstate);
43738 if (PyErr_Occurred()) SWIG_fail;
43739 }
43740 {
43741 resultobj = SWIG_From_int((int)(result));
43742 }
43743 return resultobj;
43744 fail:
43745 return NULL;
43746 }
43747
43748
43749 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
43750 PyObject *resultobj;
43751 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43752 bool result;
43753 PyObject * obj0 = 0 ;
43754 char *kwnames[] = {
43755 (char *) "self", NULL
43756 };
43757
43758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
43759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43760 if (SWIG_arg_fail(1)) SWIG_fail;
43761 {
43762 PyThreadState* __tstate = wxPyBeginAllowThreads();
43763 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
43764
43765 wxPyEndAllowThreads(__tstate);
43766 if (PyErr_Occurred()) SWIG_fail;
43767 }
43768 {
43769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43770 }
43771 return resultobj;
43772 fail:
43773 return NULL;
43774 }
43775
43776
43777 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
43778 PyObject *resultobj;
43779 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43780 bool arg2 ;
43781 PyObject * obj0 = 0 ;
43782 PyObject * obj1 = 0 ;
43783 char *kwnames[] = {
43784 (char *) "self",(char *) "d", NULL
43785 };
43786
43787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
43788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43789 if (SWIG_arg_fail(1)) SWIG_fail;
43790 {
43791 arg2 = (bool)(SWIG_As_bool(obj1));
43792 if (SWIG_arg_fail(2)) SWIG_fail;
43793 }
43794 {
43795 PyThreadState* __tstate = wxPyBeginAllowThreads();
43796 (arg1)->SetDone(arg2);
43797
43798 wxPyEndAllowThreads(__tstate);
43799 if (PyErr_Occurred()) SWIG_fail;
43800 }
43801 Py_INCREF(Py_None); resultobj = Py_None;
43802 return resultobj;
43803 fail:
43804 return NULL;
43805 }
43806
43807
43808 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
43809 PyObject *resultobj;
43810 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43811 wxRelationship result;
43812 PyObject * obj0 = 0 ;
43813 char *kwnames[] = {
43814 (char *) "self", NULL
43815 };
43816
43817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
43818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43819 if (SWIG_arg_fail(1)) SWIG_fail;
43820 {
43821 PyThreadState* __tstate = wxPyBeginAllowThreads();
43822 result = (wxRelationship)(arg1)->GetRelationship();
43823
43824 wxPyEndAllowThreads(__tstate);
43825 if (PyErr_Occurred()) SWIG_fail;
43826 }
43827 resultobj = SWIG_From_int((result));
43828 return resultobj;
43829 fail:
43830 return NULL;
43831 }
43832
43833
43834 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
43835 PyObject *resultobj;
43836 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43837 wxRelationship arg2 ;
43838 PyObject * obj0 = 0 ;
43839 PyObject * obj1 = 0 ;
43840 char *kwnames[] = {
43841 (char *) "self",(char *) "r", NULL
43842 };
43843
43844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
43845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43846 if (SWIG_arg_fail(1)) SWIG_fail;
43847 {
43848 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43849 if (SWIG_arg_fail(2)) SWIG_fail;
43850 }
43851 {
43852 PyThreadState* __tstate = wxPyBeginAllowThreads();
43853 (arg1)->SetRelationship((wxRelationship )arg2);
43854
43855 wxPyEndAllowThreads(__tstate);
43856 if (PyErr_Occurred()) SWIG_fail;
43857 }
43858 Py_INCREF(Py_None); resultobj = Py_None;
43859 return resultobj;
43860 fail:
43861 return NULL;
43862 }
43863
43864
43865 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
43866 PyObject *resultobj;
43867 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43868 wxWindow *arg2 = (wxWindow *) 0 ;
43869 bool result;
43870 PyObject * obj0 = 0 ;
43871 PyObject * obj1 = 0 ;
43872 char *kwnames[] = {
43873 (char *) "self",(char *) "otherW", NULL
43874 };
43875
43876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
43877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43878 if (SWIG_arg_fail(1)) SWIG_fail;
43879 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43880 if (SWIG_arg_fail(2)) SWIG_fail;
43881 {
43882 PyThreadState* __tstate = wxPyBeginAllowThreads();
43883 result = (bool)(arg1)->ResetIfWin(arg2);
43884
43885 wxPyEndAllowThreads(__tstate);
43886 if (PyErr_Occurred()) SWIG_fail;
43887 }
43888 {
43889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43890 }
43891 return resultobj;
43892 fail:
43893 return NULL;
43894 }
43895
43896
43897 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
43898 PyObject *resultobj;
43899 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43900 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
43901 wxWindow *arg3 = (wxWindow *) 0 ;
43902 bool result;
43903 PyObject * obj0 = 0 ;
43904 PyObject * obj1 = 0 ;
43905 PyObject * obj2 = 0 ;
43906 char *kwnames[] = {
43907 (char *) "self",(char *) "constraints",(char *) "win", NULL
43908 };
43909
43910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
43911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43912 if (SWIG_arg_fail(1)) SWIG_fail;
43913 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43914 if (SWIG_arg_fail(2)) SWIG_fail;
43915 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43916 if (SWIG_arg_fail(3)) SWIG_fail;
43917 {
43918 PyThreadState* __tstate = wxPyBeginAllowThreads();
43919 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
43920
43921 wxPyEndAllowThreads(__tstate);
43922 if (PyErr_Occurred()) SWIG_fail;
43923 }
43924 {
43925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43926 }
43927 return resultobj;
43928 fail:
43929 return NULL;
43930 }
43931
43932
43933 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43934 PyObject *resultobj;
43935 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43936 wxEdge arg2 ;
43937 wxWindow *arg3 = (wxWindow *) 0 ;
43938 wxWindow *arg4 = (wxWindow *) 0 ;
43939 int result;
43940 PyObject * obj0 = 0 ;
43941 PyObject * obj1 = 0 ;
43942 PyObject * obj2 = 0 ;
43943 PyObject * obj3 = 0 ;
43944 char *kwnames[] = {
43945 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
43946 };
43947
43948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43950 if (SWIG_arg_fail(1)) SWIG_fail;
43951 {
43952 arg2 = (wxEdge)(SWIG_As_int(obj1));
43953 if (SWIG_arg_fail(2)) SWIG_fail;
43954 }
43955 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43956 if (SWIG_arg_fail(3)) SWIG_fail;
43957 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43958 if (SWIG_arg_fail(4)) SWIG_fail;
43959 {
43960 PyThreadState* __tstate = wxPyBeginAllowThreads();
43961 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
43962
43963 wxPyEndAllowThreads(__tstate);
43964 if (PyErr_Occurred()) SWIG_fail;
43965 }
43966 {
43967 resultobj = SWIG_From_int((int)(result));
43968 }
43969 return resultobj;
43970 fail:
43971 return NULL;
43972 }
43973
43974
43975 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
43976 PyObject *obj;
43977 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43978 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
43979 Py_INCREF(obj);
43980 return Py_BuildValue((char *)"");
43981 }
43982 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
43983 PyObject *resultobj;
43984 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43985 wxIndividualLayoutConstraint *result;
43986 PyObject * obj0 = 0 ;
43987 char *kwnames[] = {
43988 (char *) "self", NULL
43989 };
43990
43991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
43992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43993 if (SWIG_arg_fail(1)) SWIG_fail;
43994 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
43995
43996 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43997 return resultobj;
43998 fail:
43999 return NULL;
44000 }
44001
44002
44003 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
44004 PyObject *resultobj;
44005 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44006 wxIndividualLayoutConstraint *result;
44007 PyObject * obj0 = 0 ;
44008 char *kwnames[] = {
44009 (char *) "self", NULL
44010 };
44011
44012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
44013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44014 if (SWIG_arg_fail(1)) SWIG_fail;
44015 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
44016
44017 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44018 return resultobj;
44019 fail:
44020 return NULL;
44021 }
44022
44023
44024 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
44025 PyObject *resultobj;
44026 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44027 wxIndividualLayoutConstraint *result;
44028 PyObject * obj0 = 0 ;
44029 char *kwnames[] = {
44030 (char *) "self", NULL
44031 };
44032
44033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
44034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44035 if (SWIG_arg_fail(1)) SWIG_fail;
44036 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
44037
44038 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44039 return resultobj;
44040 fail:
44041 return NULL;
44042 }
44043
44044
44045 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
44046 PyObject *resultobj;
44047 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44048 wxIndividualLayoutConstraint *result;
44049 PyObject * obj0 = 0 ;
44050 char *kwnames[] = {
44051 (char *) "self", NULL
44052 };
44053
44054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
44055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44056 if (SWIG_arg_fail(1)) SWIG_fail;
44057 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
44058
44059 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44060 return resultobj;
44061 fail:
44062 return NULL;
44063 }
44064
44065
44066 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
44067 PyObject *resultobj;
44068 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44069 wxIndividualLayoutConstraint *result;
44070 PyObject * obj0 = 0 ;
44071 char *kwnames[] = {
44072 (char *) "self", NULL
44073 };
44074
44075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
44076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44077 if (SWIG_arg_fail(1)) SWIG_fail;
44078 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
44079
44080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44081 return resultobj;
44082 fail:
44083 return NULL;
44084 }
44085
44086
44087 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
44088 PyObject *resultobj;
44089 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44090 wxIndividualLayoutConstraint *result;
44091 PyObject * obj0 = 0 ;
44092 char *kwnames[] = {
44093 (char *) "self", NULL
44094 };
44095
44096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
44097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44098 if (SWIG_arg_fail(1)) SWIG_fail;
44099 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
44100
44101 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44102 return resultobj;
44103 fail:
44104 return NULL;
44105 }
44106
44107
44108 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
44109 PyObject *resultobj;
44110 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44111 wxIndividualLayoutConstraint *result;
44112 PyObject * obj0 = 0 ;
44113 char *kwnames[] = {
44114 (char *) "self", NULL
44115 };
44116
44117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
44118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44119 if (SWIG_arg_fail(1)) SWIG_fail;
44120 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
44121
44122 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44123 return resultobj;
44124 fail:
44125 return NULL;
44126 }
44127
44128
44129 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
44130 PyObject *resultobj;
44131 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44132 wxIndividualLayoutConstraint *result;
44133 PyObject * obj0 = 0 ;
44134 char *kwnames[] = {
44135 (char *) "self", NULL
44136 };
44137
44138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
44139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44140 if (SWIG_arg_fail(1)) SWIG_fail;
44141 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
44142
44143 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44144 return resultobj;
44145 fail:
44146 return NULL;
44147 }
44148
44149
44150 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44151 PyObject *resultobj;
44152 wxLayoutConstraints *result;
44153 char *kwnames[] = {
44154 NULL
44155 };
44156
44157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
44158 {
44159 PyThreadState* __tstate = wxPyBeginAllowThreads();
44160 result = (wxLayoutConstraints *)new wxLayoutConstraints();
44161
44162 wxPyEndAllowThreads(__tstate);
44163 if (PyErr_Occurred()) SWIG_fail;
44164 }
44165 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
44166 return resultobj;
44167 fail:
44168 return NULL;
44169 }
44170
44171
44172 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44173 PyObject *resultobj;
44174 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44175 wxWindow *arg2 = (wxWindow *) 0 ;
44176 int *arg3 = (int *) 0 ;
44177 bool result;
44178 int temp3 ;
44179 int res3 = 0 ;
44180 PyObject * obj0 = 0 ;
44181 PyObject * obj1 = 0 ;
44182 char *kwnames[] = {
44183 (char *) "self",(char *) "win", NULL
44184 };
44185
44186 arg3 = &temp3; res3 = SWIG_NEWOBJ;
44187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
44188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44189 if (SWIG_arg_fail(1)) SWIG_fail;
44190 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44191 if (SWIG_arg_fail(2)) SWIG_fail;
44192 {
44193 PyThreadState* __tstate = wxPyBeginAllowThreads();
44194 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
44195
44196 wxPyEndAllowThreads(__tstate);
44197 if (PyErr_Occurred()) SWIG_fail;
44198 }
44199 {
44200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44201 }
44202 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
44203 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
44204 return resultobj;
44205 fail:
44206 return NULL;
44207 }
44208
44209
44210 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
44211 PyObject *resultobj;
44212 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44213 bool result;
44214 PyObject * obj0 = 0 ;
44215 char *kwnames[] = {
44216 (char *) "self", NULL
44217 };
44218
44219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
44220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44221 if (SWIG_arg_fail(1)) SWIG_fail;
44222 {
44223 PyThreadState* __tstate = wxPyBeginAllowThreads();
44224 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
44225
44226 wxPyEndAllowThreads(__tstate);
44227 if (PyErr_Occurred()) SWIG_fail;
44228 }
44229 {
44230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44231 }
44232 return resultobj;
44233 fail:
44234 return NULL;
44235 }
44236
44237
44238 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
44239 PyObject *obj;
44240 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44241 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
44242 Py_INCREF(obj);
44243 return Py_BuildValue((char *)"");
44244 }
44245 static PyMethodDef SwigMethods[] = {
44246 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
44247 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
44248 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44249 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44250 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
44251 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44252 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44253 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44254 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44255 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44256 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44257 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44258 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44259 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44260 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44261 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
44262 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
44263 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44264 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44265 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44266 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44267 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44268 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
44269 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
44270 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44271 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
44272 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44273 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44274 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44275 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44276 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44277 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44278 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44279 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44280 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44281 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44282 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44283 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44284 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
44285 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44286 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44287 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44288 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44289 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44290 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44291 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44292 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44293 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44294 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44295 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44296 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44297 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44298 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44299 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
44300 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44301 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
44302 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
44303 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
44304 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44305 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44306 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
44307 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44308 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
44309 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44310 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44311 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44312 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44313 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44314 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44315 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44316 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44317 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44318 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44319 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44320 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44321 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44322 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44323 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44324 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44325 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44326 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44327 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44328 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44329 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
44330 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
44331 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
44332 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
44333 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
44334 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
44335 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44336 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44337 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44338 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44339 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
44340 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
44341 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
44342 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44343 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44344 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44345 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44346 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44347 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44348 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44349 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44350 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44351 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44352 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
44353 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
44354 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
44355 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
44356 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44357 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
44358 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
44359 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44360 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44361 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44362 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44363 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
44364 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
44365 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44366 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44367 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
44368 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44369 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44370 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
44371 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
44372 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44373 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44374 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44375 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44376 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44377 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44378 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44379 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44380 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
44381 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44382 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44383 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
44384 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
44385 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
44386 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
44387 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
44388 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
44389 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
44390 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
44391 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
44392 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
44393 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
44394 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44395 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
44396 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
44397 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
44398 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
44399 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
44400 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
44401 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
44402 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44403 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44404 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
44405 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44406 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44407 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44408 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
44409 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
44410 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
44411 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44412 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44413 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44414 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44415 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44416 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44417 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
44418 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44419 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44420 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44421 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
44422 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
44423 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44424 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44425 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
44426 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
44427 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44428 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44429 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44430 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44431 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
44432 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
44433 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
44434 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
44435 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44436 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44437 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44438 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
44439 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44440 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44441 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44442 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44443 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44444 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
44445 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
44446 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44447 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
44448 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44449 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44450 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44451 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44452 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44453 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44454 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
44455 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44456 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44457 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
44458 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44459 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44460 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44461 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44462 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
44463 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44464 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
44465 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44466 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44467 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44468 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
44469 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44470 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44471 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
44472 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
44473 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
44474 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
44475 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44476 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
44477 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44478 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44479 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44480 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
44481 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
44482 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
44483 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
44484 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
44485 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44486 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44487 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44488 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44489 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44490 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44491 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44492 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
44493 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44494 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
44495 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44496 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
44497 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
44498 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44499 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44500 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44501 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44502 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44503 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
44504 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
44505 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44506 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44507 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44508 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
44509 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
44510 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
44511 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
44512 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
44513 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44514 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44515 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
44516 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
44517 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44518 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44519 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
44520 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
44521 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44522 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44523 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
44524 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
44525 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
44526 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
44527 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
44528 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
44529 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
44530 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
44531 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
44532 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
44533 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
44534 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
44535 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
44536 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44537 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44538 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44539 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44540 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
44541 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44542 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44543 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
44544 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44545 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
44546 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44547 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
44548 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44549 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
44550 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44551 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
44552 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44553 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
44554 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44555 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
44556 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44557 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
44558 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44559 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
44560 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44561 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
44562 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44563 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
44564 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44565 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
44566 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
44567 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
44568 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44569 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44570 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44571 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44572 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44573 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44574 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44575 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44576 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44577 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44578 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
44579 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
44580 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44581 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
44582 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44583 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
44584 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44585 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44586 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
44587 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
44588 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
44589 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
44590 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44591 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44592 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44593 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
44594 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
44595 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
44596 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
44597 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
44598 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44599 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
44600 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
44601 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
44602 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
44603 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
44604 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
44605 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
44606 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44607 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44608 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
44609 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
44610 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44611 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44612 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
44613 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
44614 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
44615 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
44616 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44617 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
44618 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44619 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
44620 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
44621 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
44622 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
44623 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44624 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44625 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44626 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44627 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44628 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
44629 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44630 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44631 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44632 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44633 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44634 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
44635 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44636 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
44637 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
44638 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44639 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
44640 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
44641 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44642 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
44643 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
44644 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
44645 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
44646 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44647 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
44648 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44649 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
44650 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
44651 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
44652 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
44653 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
44654 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44655 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44656 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44657 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44658 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44659 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44660 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
44661 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
44662 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
44663 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
44664 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44665 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44666 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44667 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44668 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44669 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
44670 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
44671 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
44672 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
44673 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44674 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44675 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44676 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44677 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44678 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44679 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44680 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44681 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44682 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44683 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44684 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44685 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44686 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44687 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44688 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44689 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44690 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44691 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
44692 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
44693 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
44694 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
44695 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
44696 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
44697 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
44698 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44699 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44700 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44701 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44702 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44703 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44704 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
44705 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44706 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
44707 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
44708 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
44709 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44710 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
44711 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
44712 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44713 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44714 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44715 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44716 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44717 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44718 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44719 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44720 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44721 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44722 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44723 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44724 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44725 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44726 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44727 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44728 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44729 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44730 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44731 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44732 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44733 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44734 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44735 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44736 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44737 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44738 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
44739 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
44740 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
44741 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44742 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44743 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44744 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44745 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44746 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
44747 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
44748 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
44749 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
44750 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
44751 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44752 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44753 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44754 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44755 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44756 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
44757 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44758 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
44759 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44760 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
44761 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44762 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
44763 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
44764 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44765 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44766 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44767 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
44768 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44769 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44770 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
44771 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44772 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44773 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
44774 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44775 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
44776 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44777 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
44778 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
44779 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44780 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
44781 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44782 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
44783 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
44784 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
44785 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44786 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44787 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44788 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
44789 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44790 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
44791 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
44792 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
44793 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44794 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
44795 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
44796 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44797 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
44798 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44799 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
44800 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
44801 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
44802 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44803 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44804 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44805 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
44806 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
44807 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44808 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44809 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44810 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44811 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
44812 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
44813 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
44814 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
44815 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
44816 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44817 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44818 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
44819 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44820 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
44821 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44822 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44823 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
44824 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44825 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
44826 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44827 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44828 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44829 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
44830 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44831 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
44832 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
44833 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
44834 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44835 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44836 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44837 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
44838 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
44839 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
44840 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
44841 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44842 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44843 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44844 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
44845 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44846 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44847 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
44848 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44849 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44850 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
44851 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44852 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44853 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44854 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
44855 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44856 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
44857 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
44858 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44859 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44860 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
44861 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
44862 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44863 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44864 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44865 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44866 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
44867 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44868 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44869 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44870 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44871 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
44872 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44873 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
44874 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
44875 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
44876 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
44877 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
44878 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44879 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
44880 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
44881 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44882 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44883 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
44884 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
44885 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
44886 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44887 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
44888 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44889 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
44890 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44891 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44892 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44893 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
44894 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
44895 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44896 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44897 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
44898 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44899 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44900 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
44901 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
44902 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
44903 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
44904 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
44905 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
44906 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
44907 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
44908 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
44909 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44910 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44911 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44912 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
44913 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
44914 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44915 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44916 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44917 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
44918 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
44919 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
44920 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
44921 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44922 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
44923 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
44924 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
44925 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44926 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44927 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
44928 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
44929 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
44930 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
44931 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44932 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44933 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
44934 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44935 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
44936 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
44937 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
44938 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44939 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44940 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
44941 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
44942 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
44943 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44944 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44945 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44946 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
44947 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
44948 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44949 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44950 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
44951 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
44952 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
44953 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44954 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44955 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
44956 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
44957 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
44958 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
44959 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
44960 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
44961 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
44962 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
44963 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44964 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44965 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
44966 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44967 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
44968 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
44969 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44970 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44971 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44972 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44973 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44974 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44975 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
44976 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
44977 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44978 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44979 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44980 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44981 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44982 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44983 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
44984 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44985 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44986 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
44987 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
44988 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
44989 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
44990 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
44991 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
44992 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44993 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44994 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44995 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44996 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44997 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44998 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44999 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45000 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45001 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
45002 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45003 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45004 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45005 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45006 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45007 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45008 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
45009 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45010 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
45011 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45012 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45013 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45014 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45015 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45016 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45017 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45018 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45019 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45020 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45021 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45022 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45023 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45024 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45025 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45026 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45027 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45028 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45029 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45030 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45031 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
45032 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45033 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
45034 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45035 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45036 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45037 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45038 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45039 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
45040 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45041 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45042 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
45043 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45044 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45045 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45046 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
45047 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45048 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45049 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
45050 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45051 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45052 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45053 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
45054 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45055 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45056 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45057 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45058 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
45059 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
45060 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
45061 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
45062 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
45063 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45064 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45065 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45066 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45067 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45068 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45069 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45070 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45071 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45072 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45073 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45074 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45075 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45076 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45077 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45078 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45079 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45080 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45081 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45082 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
45083 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
45084 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45085 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45086 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
45087 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45088 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45089 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45090 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45091 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
45092 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
45093 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
45094 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45095 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
45096 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
45097 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
45098 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
45099 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45100 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
45101 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45102 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
45103 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45104 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45105 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45106 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45107 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45108 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45109 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45110 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45111 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45112 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45113 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45114 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45115 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45116 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45117 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
45118 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45119 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45120 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45121 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45122 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45123 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45124 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45125 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
45126 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
45127 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45128 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
45129 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
45130 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
45131 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
45132 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
45133 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
45134 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45135 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45136 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45137 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45138 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45139 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45140 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45141 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45142 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
45143 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
45144 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45145 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
45146 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
45147 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
45148 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
45149 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
45150 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
45151 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45152 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
45153 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45154 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
45155 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45156 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45157 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45158 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45159 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45160 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45161 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45162 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45163 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45164 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45165 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
45166 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45167 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45168 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45169 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45170 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
45171 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
45172 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45173 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45174 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45175 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
45176 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
45177 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45178 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45179 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45180 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45181 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45182 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45183 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
45184 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
45185 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
45186 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45187 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45188 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
45189 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
45190 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45191 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45192 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45193 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45194 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45195 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
45196 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
45197 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45198 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45199 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45200 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45201 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45202 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45203 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45204 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45205 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45206 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45207 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45208 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45209 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45210 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
45211 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45212 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
45213 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45214 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
45215 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
45216 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
45217 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
45218 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
45219 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45220 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45221 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45222 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45223 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45224 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45225 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45226 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45227 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45228 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45229 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45230 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45231 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45232 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45233 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45234 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45235 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45236 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
45237 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45238 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45239 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45240 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45241 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45242 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45243 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
45244 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45245 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45247 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
45248 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45249 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45250 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
45252 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45254 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45255 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45256 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45258 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45259 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45261 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45264 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
45267 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45269 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
45271 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45274 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45277 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45279 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45280 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
45281 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45282 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45283 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45284 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45287 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
45301 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
45309 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
45328 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
45329 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
45366 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
45396 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
45399 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
45403 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
45406 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
45416 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
45428 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
45440 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
45450 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
45460 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
45474 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
45481 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
45482 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
45483 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
45484 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
45485 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
45490 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
45517 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
45529 { NULL, NULL, 0, NULL }
45530 };
45531
45532
45533 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
45534
45535 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
45536 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
45537 }
45538 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
45539 return (void *)((wxSizer *) ((wxBoxSizer *) x));
45540 }
45541 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
45542 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
45543 }
45544 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
45545 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45546 }
45547 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
45548 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
45549 }
45550 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
45551 return (void *)((wxSizer *) ((wxGridSizer *) x));
45552 }
45553 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
45554 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
45555 }
45556 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
45557 return (void *)((wxSizer *) ((wxPySizer *) x));
45558 }
45559 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
45560 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
45561 }
45562 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
45563 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45564 }
45565 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
45566 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
45567 }
45568 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
45569 return (void *)((wxEvent *) ((wxMenuEvent *) x));
45570 }
45571 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
45572 return (void *)((wxEvent *) ((wxCloseEvent *) x));
45573 }
45574 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
45575 return (void *)((wxEvent *) ((wxMouseEvent *) x));
45576 }
45577 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
45578 return (void *)((wxEvent *) ((wxEraseEvent *) x));
45579 }
45580 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
45581 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
45582 }
45583 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
45584 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
45585 }
45586 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
45587 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
45588 }
45589 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
45590 return (void *)((wxEvent *) ((wxPyEvent *) x));
45591 }
45592 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
45593 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
45594 }
45595 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
45596 return (void *)((wxEvent *) ((wxIdleEvent *) x));
45597 }
45598 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
45599 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
45600 }
45601 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
45602 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
45603 }
45604 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
45605 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
45606 }
45607 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
45608 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
45609 }
45610 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
45611 return (void *)((wxEvent *) ((wxActivateEvent *) x));
45612 }
45613 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
45614 return (void *)((wxEvent *) ((wxSizeEvent *) x));
45615 }
45616 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
45617 return (void *)((wxEvent *) ((wxMoveEvent *) x));
45618 }
45619 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
45620 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
45621 }
45622 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
45623 return (void *)((wxEvent *) ((wxPaintEvent *) x));
45624 }
45625 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
45626 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
45627 }
45628 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
45629 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
45630 }
45631 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
45632 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
45633 }
45634 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
45635 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
45636 }
45637 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
45638 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
45639 }
45640 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
45641 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
45642 }
45643 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
45644 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
45645 }
45646 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
45647 return (void *)((wxEvent *) ((wxFocusEvent *) x));
45648 }
45649 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
45650 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
45651 }
45652 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
45653 return (void *)((wxEvent *) ((wxShowEvent *) x));
45654 }
45655 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
45656 return (void *)((wxEvent *) ((wxCommandEvent *) x));
45657 }
45658 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
45659 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
45660 }
45661 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
45662 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45663 }
45664 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
45665 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
45666 }
45667 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
45668 return (void *)((wxEvent *) ((wxKeyEvent *) x));
45669 }
45670 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
45671 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
45672 }
45673 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
45674 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
45675 }
45676 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
45677 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
45678 }
45679 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
45680 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
45681 }
45682 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
45683 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
45684 }
45685 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
45686 return (void *)((wxControl *) ((wxControlWithItems *) x));
45687 }
45688 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
45689 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
45690 }
45691 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
45692 return (void *)((wxEvtHandler *) ((wxWindow *) x));
45693 }
45694 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
45695 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
45696 }
45697 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
45698 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
45699 }
45700 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
45701 return (void *)((wxEvtHandler *) ((wxValidator *) x));
45702 }
45703 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
45704 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
45705 }
45706 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
45707 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
45708 }
45709 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
45710 return (void *)((wxEvtHandler *) ((wxMenu *) x));
45711 }
45712 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
45713 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
45714 }
45715 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
45716 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
45717 }
45718 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
45719 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
45720 }
45721 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
45722 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
45723 }
45724 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
45725 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
45726 }
45727 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
45728 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45729 }
45730 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
45731 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
45732 }
45733 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
45734 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
45735 }
45736 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
45737 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
45738 }
45739 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
45740 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45741 }
45742 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
45743 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
45744 }
45745 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
45746 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
45747 }
45748 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
45749 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
45750 }
45751 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
45752 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
45753 }
45754 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
45755 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
45756 }
45757 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
45758 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
45759 }
45760 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
45761 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
45762 }
45763 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
45764 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
45765 }
45766 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
45767 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
45768 }
45769 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
45770 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
45771 }
45772 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
45773 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
45774 }
45775 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
45776 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
45777 }
45778 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
45779 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
45780 }
45781 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
45782 return (void *)((wxObject *) ((wxSizerItem *) x));
45783 }
45784 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
45785 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
45786 }
45787 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
45788 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
45789 }
45790 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
45791 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
45792 }
45793 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
45794 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
45795 }
45796 static void *_p_wxSizerTo_p_wxObject(void *x) {
45797 return (void *)((wxObject *) ((wxSizer *) x));
45798 }
45799 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
45800 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
45801 }
45802 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
45803 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
45804 }
45805 static void *_p_wxEventTo_p_wxObject(void *x) {
45806 return (void *)((wxObject *) ((wxEvent *) x));
45807 }
45808 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
45809 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
45810 }
45811 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
45812 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
45813 }
45814 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
45815 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
45816 }
45817 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
45818 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
45819 }
45820 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
45821 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
45822 }
45823 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
45824 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
45825 }
45826 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
45827 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
45828 }
45829 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
45830 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
45831 }
45832 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
45833 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
45834 }
45835 static void *_p_wxControlTo_p_wxObject(void *x) {
45836 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
45837 }
45838 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
45839 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
45840 }
45841 static void *_p_wxFSFileTo_p_wxObject(void *x) {
45842 return (void *)((wxObject *) ((wxFSFile *) x));
45843 }
45844 static void *_p_wxPySizerTo_p_wxObject(void *x) {
45845 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
45846 }
45847 static void *_p_wxPyEventTo_p_wxObject(void *x) {
45848 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
45849 }
45850 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
45851 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
45852 }
45853 static void *_p_wxShowEventTo_p_wxObject(void *x) {
45854 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
45855 }
45856 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
45857 return (void *)((wxObject *) ((wxMenuItem *) x));
45858 }
45859 static void *_p_wxDateEventTo_p_wxObject(void *x) {
45860 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
45861 }
45862 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
45863 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
45864 }
45865 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
45866 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
45867 }
45868 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
45869 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
45870 }
45871 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
45872 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
45873 }
45874 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
45875 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
45876 }
45877 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
45878 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
45879 }
45880 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
45881 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
45882 }
45883 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
45884 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
45885 }
45886 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
45887 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
45888 }
45889 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
45890 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
45891 }
45892 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
45893 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
45894 }
45895 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
45896 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
45897 }
45898 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
45899 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
45900 }
45901 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
45902 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
45903 }
45904 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
45905 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45906 }
45907 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
45908 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
45909 }
45910 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
45911 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
45912 }
45913 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
45914 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
45915 }
45916 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
45917 return (void *)((wxObject *) ((wxImageHandler *) x));
45918 }
45919 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
45920 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
45921 }
45922 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
45923 return (void *)((wxObject *) ((wxEvtHandler *) x));
45924 }
45925 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
45926 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45927 }
45928 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
45929 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
45930 }
45931 static void *_p_wxImageTo_p_wxObject(void *x) {
45932 return (void *)((wxObject *) ((wxImage *) x));
45933 }
45934 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
45935 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
45936 }
45937 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
45938 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45939 }
45940 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
45941 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
45942 }
45943 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
45944 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
45945 }
45946 static void *_p_wxWindowTo_p_wxObject(void *x) {
45947 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
45948 }
45949 static void *_p_wxMenuTo_p_wxObject(void *x) {
45950 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
45951 }
45952 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
45953 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
45954 }
45955 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
45956 return (void *)((wxObject *) ((wxFileSystem *) x));
45957 }
45958 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
45959 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
45960 }
45961 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
45962 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
45963 }
45964 static void *_p_wxPyAppTo_p_wxObject(void *x) {
45965 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
45966 }
45967 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
45968 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
45969 }
45970 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
45971 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
45972 }
45973 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
45974 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
45975 }
45976 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
45977 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
45978 }
45979 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
45980 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
45981 }
45982 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
45983 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
45984 }
45985 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
45986 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
45987 }
45988 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
45989 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
45990 }
45991 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
45992 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
45993 }
45994 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
45995 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
45996 }
45997 static void *_p_wxValidatorTo_p_wxObject(void *x) {
45998 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
45999 }
46000 static void *_p_wxControlTo_p_wxWindow(void *x) {
46001 return (void *)((wxWindow *) ((wxControl *) x));
46002 }
46003 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
46004 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
46005 }
46006 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
46007 return (void *)((wxWindow *) ((wxMenuBar *) x));
46008 }
46009 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
46010 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
46011 }
46012 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
46013 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
46014 }
46015 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
46016 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
46017 }
46018 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
46019 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
46020 }
46021 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
46022 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
46023 }
46024 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
46025 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46026 }
46027 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
46028 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
46029 }
46030 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
46031 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
46032 }
46033 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
46034 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
46035 }
46036 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
46037 return (void *)((wxValidator *) ((wxPyValidator *) x));
46038 }
46039 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}};
46040 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}};
46041 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}};
46042 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}};
46043 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}};
46044 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}};
46045 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}};
46046 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}};
46047 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}};
46048 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}};
46049 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}};
46050 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}};
46051 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}};
46052 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}};
46053 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}};
46054 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}};
46055 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}};
46056 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}};
46057 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}};
46058 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}};
46059 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}};
46060 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}};
46061 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}};
46062 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}};
46063 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}};
46064 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}};
46065 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}};
46066 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}};
46067 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}};
46068 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}};
46069 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}};
46070 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}};
46071 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}};
46072 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}};
46073 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}};
46074 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}};
46075 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}};
46076 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}};
46077 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}};
46078 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}};
46079 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}};
46080 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}};
46081 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}};
46082 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}};
46083 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}};
46084 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}};
46085 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}};
46086 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}};
46087 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}};
46088 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}};
46089 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}};
46090 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}};
46091 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}};
46092 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}};
46093 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}};
46094 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}};
46095 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}};
46096 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}};
46097 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}};
46098 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}};
46099 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}};
46100 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}};
46101 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}};
46102 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}};
46103 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}};
46104 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}};
46105 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}};
46106 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}};
46107 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}};
46108 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}};
46109 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}};
46110 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}};
46111 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}};
46112 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}};
46113 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}};
46114 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}};
46115 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}};
46116 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}};
46117 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}};
46118 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}};
46119 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}};
46120 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}};
46121 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}};
46122 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}};
46123 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}};
46124 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}};
46125 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}};
46126 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}};
46127 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}};
46128 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}};
46129 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}};
46130 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}};
46131 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}};
46132 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}};
46133 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}};
46134 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}};
46135 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}};
46136 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}};
46137 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}};
46138 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}};
46139 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}};
46140 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}};
46141 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}};
46142 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}};
46143 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}};
46144 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}};
46145 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}};
46146 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}};
46147 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}};
46148 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}};
46149 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}};
46150 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}};
46151 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}};
46152 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}};
46153 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}};
46154 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}};
46155 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}};
46156 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}};
46157 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}};
46158 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}};
46159 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}};
46160 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}};
46161 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}};
46162 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}};
46163 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}};
46164 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}};
46165 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}};
46166
46167 static swig_type_info *swig_types_initial[] = {
46168 _swigt__p_wxLayoutConstraints,
46169 _swigt__p_wxRealPoint,
46170 _swigt__p_wxSizerItem,
46171 _swigt__p_wxGBSizerItem,
46172 _swigt__p_wxScrollEvent,
46173 _swigt__p_wxEventLoop,
46174 _swigt__p_wxIndividualLayoutConstraint,
46175 _swigt__p_wxSizer,
46176 _swigt__p_wxBoxSizer,
46177 _swigt__p_wxStaticBoxSizer,
46178 _swigt__p_wxGridBagSizer,
46179 _swigt__p_wxAcceleratorEntry,
46180 _swigt__p_wxUpdateUIEvent,
46181 _swigt__p_wxEvent,
46182 _swigt__p_wxMenu,
46183 _swigt__p_wxGridSizer,
46184 _swigt__p_wxFlexGridSizer,
46185 _swigt__p_wxInitDialogEvent,
46186 _swigt__p_wxItemContainer,
46187 _swigt__p_wxNcPaintEvent,
46188 _swigt__p_wxPaintEvent,
46189 _swigt__p_wxSysColourChangedEvent,
46190 _swigt__p_wxMouseCaptureChangedEvent,
46191 _swigt__p_wxDisplayChangedEvent,
46192 _swigt__p_wxPaletteChangedEvent,
46193 _swigt__p_wxControl,
46194 _swigt__p_wxFont,
46195 _swigt__p_wxMenuBarBase,
46196 _swigt__p_wxSetCursorEvent,
46197 _swigt__p_wxFSFile,
46198 _swigt__p_wxCaret,
46199 _swigt__ptrdiff_t,
46200 _swigt__std__ptrdiff_t,
46201 _swigt__p_wxRegion,
46202 _swigt__p_wxPoint2D,
46203 _swigt__p_int,
46204 _swigt__p_wxSize,
46205 _swigt__p_wxDC,
46206 _swigt__p_wxPySizer,
46207 _swigt__p_wxVisualAttributes,
46208 _swigt__p_wxNotifyEvent,
46209 _swigt__p_wxPyEvent,
46210 _swigt__p_wxPropagationDisabler,
46211 _swigt__p_form_ops_t,
46212 _swigt__p_wxAppTraits,
46213 _swigt__p_wxArrayString,
46214 _swigt__p_wxShowEvent,
46215 _swigt__p_wxToolTip,
46216 _swigt__p_wxMoveEvent,
46217 _swigt__p_wxSizeEvent,
46218 _swigt__p_wxActivateEvent,
46219 _swigt__p_wxIconizeEvent,
46220 _swigt__p_wxMaximizeEvent,
46221 _swigt__p_wxQueryNewPaletteEvent,
46222 _swigt__p_wxWindowCreateEvent,
46223 _swigt__p_wxIdleEvent,
46224 _swigt__p_wxDateEvent,
46225 _swigt__p_wxMenuItem,
46226 _swigt__p_wxStaticBox,
46227 _swigt__p_long,
46228 _swigt__p_wxDuplexMode,
46229 _swigt__p_wxTIFFHandler,
46230 _swigt__p_wxXPMHandler,
46231 _swigt__p_wxPNMHandler,
46232 _swigt__p_wxJPEGHandler,
46233 _swigt__p_wxPCXHandler,
46234 _swigt__p_wxGIFHandler,
46235 _swigt__p_wxPNGHandler,
46236 _swigt__p_wxANIHandler,
46237 _swigt__p_wxMemoryFSHandler,
46238 _swigt__p_wxZipFSHandler,
46239 _swigt__p_wxInternetFSHandler,
46240 _swigt__p_wxPyFileSystemHandler,
46241 _swigt__p_wxEvtHandler,
46242 _swigt__p_wxCURHandler,
46243 _swigt__p_wxICOHandler,
46244 _swigt__p_wxBMPHandler,
46245 _swigt__p_wxImageHandler,
46246 _swigt__p_wxFileSystemHandler,
46247 _swigt__p_wxRect,
46248 _swigt__p_wxButton,
46249 _swigt__p_wxGBSpan,
46250 _swigt__p_wxPropagateOnce,
46251 _swigt__p_wxAcceleratorTable,
46252 _swigt__p_wxStdDialogButtonSizer,
46253 _swigt__p_char,
46254 _swigt__p_wxGBPosition,
46255 _swigt__p_wxImage,
46256 _swigt__p_wxFrame,
46257 _swigt__p_wxScrollWinEvent,
46258 _swigt__p_wxPaperSize,
46259 _swigt__p_wxImageHistogram,
46260 _swigt__p_wxPoint,
46261 _swigt__p_wxCursor,
46262 _swigt__p_wxObject,
46263 _swigt__p_wxInputStream,
46264 _swigt__p_wxOutputStream,
46265 _swigt__p_wxPyInputStream,
46266 _swigt__p_wxDateTime,
46267 _swigt__p_wxKeyEvent,
46268 _swigt__p_wxNavigationKeyEvent,
46269 _swigt__p_wxWindowDestroyEvent,
46270 _swigt__p_unsigned_long,
46271 _swigt__p_wxWindow,
46272 _swigt__p_wxMenuBar,
46273 _swigt__p_wxFileSystem,
46274 _swigt__p_wxBitmap,
46275 _swigt__unsigned_int,
46276 _swigt__p_unsigned_int,
46277 _swigt__p_wxMenuEvent,
46278 _swigt__p_wxContextMenuEvent,
46279 _swigt__p_unsigned_char,
46280 _swigt__p_wxEraseEvent,
46281 _swigt__p_wxMouseEvent,
46282 _swigt__p_wxCloseEvent,
46283 _swigt__p_wxPyApp,
46284 _swigt__p_wxCommandEvent,
46285 _swigt__p_wxPyCommandEvent,
46286 _swigt__p_wxPyDropTarget,
46287 _swigt__p_wxQuantize,
46288 _swigt__p_wxChildFocusEvent,
46289 _swigt__p_wxFocusEvent,
46290 _swigt__p_wxDropFilesEvent,
46291 _swigt__p_wxControlWithItems,
46292 _swigt__p_wxColour,
46293 _swigt__p_wxValidator,
46294 _swigt__p_wxPyValidator,
46295 0
46296 };
46297
46298
46299 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
46300
46301 static swig_const_info swig_const_table[] = {
46302 {0, 0, 0, 0.0, 0, 0}};
46303
46304 #ifdef __cplusplus
46305 }
46306 #endif
46307
46308
46309 #ifdef __cplusplus
46310 extern "C" {
46311 #endif
46312
46313 /* Python-specific SWIG API */
46314 #define SWIG_newvarlink() SWIG_Python_newvarlink()
46315 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
46316 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
46317
46318 /* -----------------------------------------------------------------------------
46319 * global variable support code.
46320 * ----------------------------------------------------------------------------- */
46321
46322 typedef struct swig_globalvar {
46323 char *name; /* Name of global variable */
46324 PyObject *(*get_attr)(); /* Return the current value */
46325 int (*set_attr)(PyObject *); /* Set the value */
46326 struct swig_globalvar *next;
46327 } swig_globalvar;
46328
46329 typedef struct swig_varlinkobject {
46330 PyObject_HEAD
46331 swig_globalvar *vars;
46332 } swig_varlinkobject;
46333
46334 static PyObject *
46335 swig_varlink_repr(swig_varlinkobject *v) {
46336 v = v;
46337 return PyString_FromString("<Swig global variables>");
46338 }
46339
46340 static int
46341 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
46342 swig_globalvar *var;
46343 flags = flags;
46344 fprintf(fp,"Swig global variables { ");
46345 for (var = v->vars; var; var=var->next) {
46346 fprintf(fp,"%s", var->name);
46347 if (var->next) fprintf(fp,", ");
46348 }
46349 fprintf(fp," }\n");
46350 return 0;
46351 }
46352
46353 static PyObject *
46354 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
46355 swig_globalvar *var = v->vars;
46356 while (var) {
46357 if (strcmp(var->name,n) == 0) {
46358 return (*var->get_attr)();
46359 }
46360 var = var->next;
46361 }
46362 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46363 return NULL;
46364 }
46365
46366 static int
46367 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
46368 swig_globalvar *var = v->vars;
46369 while (var) {
46370 if (strcmp(var->name,n) == 0) {
46371 return (*var->set_attr)(p);
46372 }
46373 var = var->next;
46374 }
46375 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46376 return 1;
46377 }
46378
46379 static PyTypeObject varlinktype = {
46380 PyObject_HEAD_INIT(0)
46381 0, /* Number of items in variable part (ob_size) */
46382 (char *)"swigvarlink", /* Type name (tp_name) */
46383 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
46384 0, /* Itemsize (tp_itemsize) */
46385 0, /* Deallocator (tp_dealloc) */
46386 (printfunc) swig_varlink_print, /* Print (tp_print) */
46387 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
46388 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
46389 0, /* tp_compare */
46390 (reprfunc) swig_varlink_repr, /* tp_repr */
46391 0, /* tp_as_number */
46392 0, /* tp_as_sequence */
46393 0, /* tp_as_mapping */
46394 0, /* tp_hash */
46395 0, /* tp_call */
46396 0, /* tp_str */
46397 0, /* tp_getattro */
46398 0, /* tp_setattro */
46399 0, /* tp_as_buffer */
46400 0, /* tp_flags */
46401 0, /* tp_doc */
46402 #if PY_VERSION_HEX >= 0x02000000
46403 0, /* tp_traverse */
46404 0, /* tp_clear */
46405 #endif
46406 #if PY_VERSION_HEX >= 0x02010000
46407 0, /* tp_richcompare */
46408 0, /* tp_weaklistoffset */
46409 #endif
46410 #if PY_VERSION_HEX >= 0x02020000
46411 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
46412 #endif
46413 #if PY_VERSION_HEX >= 0x02030000
46414 0, /* tp_del */
46415 #endif
46416 #ifdef COUNT_ALLOCS
46417 0,0,0,0 /* tp_alloc -> tp_next */
46418 #endif
46419 };
46420
46421 /* Create a variable linking object for use later */
46422 static PyObject *
46423 SWIG_Python_newvarlink(void) {
46424 swig_varlinkobject *result = 0;
46425 result = PyMem_NEW(swig_varlinkobject,1);
46426 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
46427 result->ob_type = &varlinktype;
46428 result->vars = 0;
46429 result->ob_refcnt = 0;
46430 Py_XINCREF((PyObject *) result);
46431 return ((PyObject*) result);
46432 }
46433
46434 static void
46435 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
46436 swig_varlinkobject *v;
46437 swig_globalvar *gv;
46438 v= (swig_varlinkobject *) p;
46439 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
46440 gv->name = (char *) malloc(strlen(name)+1);
46441 strcpy(gv->name,name);
46442 gv->get_attr = get_attr;
46443 gv->set_attr = set_attr;
46444 gv->next = v->vars;
46445 v->vars = gv;
46446 }
46447
46448 /* -----------------------------------------------------------------------------
46449 * constants/methods manipulation
46450 * ----------------------------------------------------------------------------- */
46451
46452 /* Install Constants */
46453 static void
46454 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
46455 PyObject *obj = 0;
46456 size_t i;
46457 for (i = 0; constants[i].type; i++) {
46458 switch(constants[i].type) {
46459 case SWIG_PY_INT:
46460 obj = PyInt_FromLong(constants[i].lvalue);
46461 break;
46462 case SWIG_PY_FLOAT:
46463 obj = PyFloat_FromDouble(constants[i].dvalue);
46464 break;
46465 case SWIG_PY_STRING:
46466 if (constants[i].pvalue) {
46467 obj = PyString_FromString((char *) constants[i].pvalue);
46468 } else {
46469 Py_INCREF(Py_None);
46470 obj = Py_None;
46471 }
46472 break;
46473 case SWIG_PY_POINTER:
46474 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
46475 break;
46476 case SWIG_PY_BINARY:
46477 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
46478 break;
46479 default:
46480 obj = 0;
46481 break;
46482 }
46483 if (obj) {
46484 PyDict_SetItemString(d,constants[i].name,obj);
46485 Py_DECREF(obj);
46486 }
46487 }
46488 }
46489
46490 /* -----------------------------------------------------------------------------*/
46491 /* Fix SwigMethods to carry the callback ptrs when needed */
46492 /* -----------------------------------------------------------------------------*/
46493
46494 static void
46495 SWIG_Python_FixMethods(PyMethodDef *methods,
46496 swig_const_info *const_table,
46497 swig_type_info **types,
46498 swig_type_info **types_initial) {
46499 size_t i;
46500 for (i = 0; methods[i].ml_name; ++i) {
46501 char *c = methods[i].ml_doc;
46502 if (c && (c = strstr(c, "swig_ptr: "))) {
46503 int j;
46504 swig_const_info *ci = 0;
46505 char *name = c + 10;
46506 for (j = 0; const_table[j].type; j++) {
46507 if (strncmp(const_table[j].name, name,
46508 strlen(const_table[j].name)) == 0) {
46509 ci = &(const_table[j]);
46510 break;
46511 }
46512 }
46513 if (ci) {
46514 size_t shift = (ci->ptype) - types;
46515 swig_type_info *ty = types_initial[shift];
46516 size_t ldoc = (c - methods[i].ml_doc);
46517 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
46518 char *ndoc = (char*)malloc(ldoc + lptr + 10);
46519 char *buff = ndoc;
46520 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
46521 strncpy(buff, methods[i].ml_doc, ldoc);
46522 buff += ldoc;
46523 strncpy(buff, "swig_ptr: ", 10);
46524 buff += 10;
46525 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
46526 methods[i].ml_doc = ndoc;
46527 }
46528 }
46529 }
46530 }
46531
46532 /* -----------------------------------------------------------------------------*
46533 * Initialize type list
46534 * -----------------------------------------------------------------------------*/
46535
46536 #if PY_MAJOR_VERSION < 2
46537 /* PyModule_AddObject function was introduced in Python 2.0. The following function
46538 is copied out of Python/modsupport.c in python version 2.3.4 */
46539 static int
46540 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
46541 {
46542 PyObject *dict;
46543 if (!PyModule_Check(m)) {
46544 PyErr_SetString(PyExc_TypeError,
46545 "PyModule_AddObject() needs module as first arg");
46546 return -1;
46547 }
46548 if (!o) {
46549 PyErr_SetString(PyExc_TypeError,
46550 "PyModule_AddObject() needs non-NULL value");
46551 return -1;
46552 }
46553
46554 dict = PyModule_GetDict(m);
46555 if (dict == NULL) {
46556 /* Internal error -- modules must have a dict! */
46557 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
46558 PyModule_GetName(m));
46559 return -1;
46560 }
46561 if (PyDict_SetItemString(dict, name, o))
46562 return -1;
46563 Py_DECREF(o);
46564 return 0;
46565 }
46566 #endif
46567
46568 static swig_type_info **
46569 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
46570 static PyMethodDef swig_empty_runtime_method_table[] = {
46571 {
46572 NULL, NULL, 0, NULL
46573 }
46574 };/* Sentinel */
46575
46576 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
46577 swig_empty_runtime_method_table);
46578 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
46579 if (pointer && module) {
46580 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
46581 }
46582 return type_list_handle;
46583 }
46584
46585 static swig_type_info **
46586 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
46587 swig_type_info **type_pointer;
46588
46589 /* first check if module already created */
46590 type_pointer = SWIG_Python_GetTypeListHandle();
46591 if (type_pointer) {
46592 return type_pointer;
46593 } else {
46594 /* create a new module and variable */
46595 return SWIG_Python_SetTypeListHandle(type_list_handle);
46596 }
46597 }
46598
46599 #ifdef __cplusplus
46600 }
46601 #endif
46602
46603 /* -----------------------------------------------------------------------------*
46604 * Partial Init method
46605 * -----------------------------------------------------------------------------*/
46606
46607 #ifdef SWIG_LINK_RUNTIME
46608 #ifdef __cplusplus
46609 extern "C"
46610 #endif
46611 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
46612 #endif
46613
46614 #ifdef __cplusplus
46615 extern "C"
46616 #endif
46617 SWIGEXPORT(void) SWIG_init(void) {
46618 static PyObject *SWIG_globals = 0;
46619 static int typeinit = 0;
46620 PyObject *m, *d;
46621 int i;
46622 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
46623
46624 /* Fix SwigMethods to carry the callback ptrs when needed */
46625 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
46626
46627 m = Py_InitModule((char *) SWIG_name, SwigMethods);
46628 d = PyModule_GetDict(m);
46629
46630 if (!typeinit) {
46631 #ifdef SWIG_LINK_RUNTIME
46632 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
46633 #else
46634 # ifndef SWIG_STATIC_RUNTIME
46635 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
46636 # endif
46637 #endif
46638 for (i = 0; swig_types_initial[i]; i++) {
46639 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
46640 }
46641 typeinit = 1;
46642 }
46643 SWIG_InstallConstants(d,swig_const_table);
46644
46645
46646 #ifndef wxPyUSE_EXPORT
46647 // Make our API structure a CObject so other modules can import it
46648 // from this module.
46649 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
46650 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
46651 Py_XDECREF(cobj);
46652 #endif
46653
46654 {
46655 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
46656 }
46657 {
46658 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
46659 }
46660 {
46661 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
46662 }
46663 {
46664 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
46665 }
46666 {
46667 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
46668 }
46669 {
46670 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
46671 }
46672 {
46673 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
46674 }
46675 {
46676 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
46677 }
46678 {
46679 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
46680 }
46681 {
46682 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
46683 }
46684 {
46685 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
46686 }
46687 {
46688 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
46689 }
46690 {
46691 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
46692 }
46693 {
46694 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
46695 }
46696 {
46697 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
46698 }
46699 {
46700 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
46701 }
46702 {
46703 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
46704 }
46705 {
46706 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
46707 }
46708 {
46709 PyDict_SetItemString(d,"ED_CLIENT_MARGIN", SWIG_From_int((int)(wxED_CLIENT_MARGIN)));
46710 }
46711 {
46712 PyDict_SetItemString(d,"ED_BUTTONS_BOTTOM", SWIG_From_int((int)(wxED_BUTTONS_BOTTOM)));
46713 }
46714 {
46715 PyDict_SetItemString(d,"ED_BUTTONS_RIGHT", SWIG_From_int((int)(wxED_BUTTONS_RIGHT)));
46716 }
46717 {
46718 PyDict_SetItemString(d,"ED_STATIC_LINE", SWIG_From_int((int)(wxED_STATIC_LINE)));
46719 }
46720 {
46721 PyDict_SetItemString(d,"EXT_DIALOG_STYLE", SWIG_From_int((int)(wxEXT_DIALOG_STYLE)));
46722 }
46723 {
46724 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
46725 }
46726 {
46727 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
46728 }
46729 {
46730 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
46731 }
46732 {
46733 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
46734 }
46735 {
46736 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
46737 }
46738 {
46739 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
46740 }
46741 {
46742 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
46743 }
46744 {
46745 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
46746 }
46747 {
46748 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
46749 }
46750 {
46751 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
46752 }
46753 {
46754 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
46755 }
46756 {
46757 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
46758 }
46759 {
46760 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
46761 }
46762 {
46763 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
46764 }
46765 {
46766 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
46767 }
46768 {
46769 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
46770 }
46771 {
46772 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
46773 }
46774 {
46775 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
46776 }
46777 {
46778 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
46779 }
46780 {
46781 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
46782 }
46783 {
46784 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
46785 }
46786 {
46787 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
46788 }
46789 {
46790 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
46791 }
46792 {
46793 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
46794 }
46795 {
46796 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
46797 }
46798 {
46799 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
46800 }
46801 {
46802 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
46803 }
46804 {
46805 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
46806 }
46807 {
46808 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
46809 }
46810 {
46811 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
46812 }
46813 {
46814 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
46815 }
46816 {
46817 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
46818 }
46819 {
46820 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
46821 }
46822 {
46823 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
46824 }
46825 {
46826 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
46827 }
46828 {
46829 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
46830 }
46831 {
46832 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
46833 }
46834 {
46835 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
46836 }
46837 {
46838 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
46839 }
46840 {
46841 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
46842 }
46843 {
46844 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
46845 }
46846 {
46847 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
46848 }
46849 {
46850 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
46851 }
46852 {
46853 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
46854 }
46855 {
46856 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
46857 }
46858 {
46859 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
46860 }
46861 {
46862 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
46863 }
46864 {
46865 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
46866 }
46867 {
46868 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
46869 }
46870 {
46871 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
46872 }
46873 {
46874 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
46875 }
46876 {
46877 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
46878 }
46879 {
46880 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
46881 }
46882 {
46883 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
46884 }
46885 {
46886 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
46887 }
46888 {
46889 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
46890 }
46891 {
46892 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
46893 }
46894 {
46895 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
46896 }
46897 {
46898 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
46899 }
46900 {
46901 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
46902 }
46903 {
46904 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
46905 }
46906 {
46907 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
46908 }
46909 {
46910 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
46911 }
46912 {
46913 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
46914 }
46915 {
46916 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
46917 }
46918 {
46919 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
46920 }
46921 {
46922 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
46923 }
46924 {
46925 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
46926 }
46927 {
46928 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
46929 }
46930 {
46931 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
46932 }
46933 {
46934 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
46935 }
46936 {
46937 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
46938 }
46939 {
46940 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
46941 }
46942 {
46943 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
46944 }
46945 {
46946 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
46947 }
46948 {
46949 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
46950 }
46951 {
46952 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
46953 }
46954 {
46955 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
46956 }
46957 {
46958 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
46959 }
46960 {
46961 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
46962 }
46963 {
46964 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
46965 }
46966 {
46967 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
46968 }
46969 {
46970 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
46971 }
46972 {
46973 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
46974 }
46975 {
46976 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
46977 }
46978 {
46979 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
46980 }
46981 {
46982 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
46983 }
46984 {
46985 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
46986 }
46987 {
46988 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
46989 }
46990 {
46991 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
46992 }
46993 {
46994 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
46995 }
46996 {
46997 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
46998 }
46999 {
47000 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
47001 }
47002 {
47003 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
47004 }
47005 {
47006 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
47007 }
47008 {
47009 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
47010 }
47011 {
47012 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
47013 }
47014 {
47015 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
47016 }
47017 {
47018 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
47019 }
47020 {
47021 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
47022 }
47023 {
47024 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
47025 }
47026 {
47027 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
47028 }
47029 {
47030 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
47031 }
47032 {
47033 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
47034 }
47035 {
47036 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
47037 }
47038 {
47039 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
47040 }
47041 {
47042 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
47043 }
47044 {
47045 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
47046 }
47047 {
47048 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
47049 }
47050 {
47051 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
47052 }
47053 {
47054 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
47055 }
47056 {
47057 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
47058 }
47059 {
47060 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
47061 }
47062 {
47063 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
47064 }
47065 {
47066 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
47067 }
47068 {
47069 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
47070 }
47071 {
47072 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
47073 }
47074 {
47075 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
47076 }
47077 {
47078 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
47079 }
47080 {
47081 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
47082 }
47083 {
47084 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
47085 }
47086 {
47087 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
47088 }
47089 {
47090 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
47091 }
47092 {
47093 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
47094 }
47095 {
47096 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
47097 }
47098 {
47099 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
47100 }
47101 {
47102 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
47103 }
47104 {
47105 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
47106 }
47107 {
47108 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
47109 }
47110 {
47111 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
47112 }
47113 {
47114 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
47115 }
47116 {
47117 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
47118 }
47119 {
47120 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
47121 }
47122 {
47123 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
47124 }
47125 {
47126 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
47127 }
47128 {
47129 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
47130 }
47131 {
47132 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
47133 }
47134 {
47135 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
47136 }
47137 {
47138 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
47139 }
47140 {
47141 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
47142 }
47143 {
47144 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
47145 }
47146 {
47147 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
47148 }
47149 {
47150 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
47151 }
47152 {
47153 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
47154 }
47155 {
47156 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
47157 }
47158 {
47159 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
47160 }
47161 {
47162 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
47163 }
47164 {
47165 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
47166 }
47167 {
47168 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
47169 }
47170 {
47171 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
47172 }
47173 {
47174 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
47175 }
47176 {
47177 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
47178 }
47179 {
47180 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
47181 }
47182 {
47183 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
47184 }
47185 {
47186 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
47187 }
47188 {
47189 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
47190 }
47191 {
47192 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
47193 }
47194 {
47195 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
47196 }
47197 {
47198 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
47199 }
47200 {
47201 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
47202 }
47203 {
47204 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
47205 }
47206 {
47207 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
47208 }
47209 {
47210 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
47211 }
47212 {
47213 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
47214 }
47215 {
47216 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
47217 }
47218 {
47219 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
47220 }
47221 {
47222 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
47223 }
47224 {
47225 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
47226 }
47227 {
47228 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
47229 }
47230 {
47231 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
47232 }
47233 {
47234 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
47235 }
47236 {
47237 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
47238 }
47239 {
47240 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
47241 }
47242 {
47243 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
47244 }
47245 {
47246 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
47247 }
47248 {
47249 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
47250 }
47251 {
47252 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
47253 }
47254 {
47255 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
47256 }
47257 {
47258 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
47259 }
47260 {
47261 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
47262 }
47263 {
47264 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
47265 }
47266 {
47267 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
47268 }
47269 {
47270 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
47271 }
47272 {
47273 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
47274 }
47275 {
47276 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
47277 }
47278 {
47279 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
47280 }
47281 {
47282 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
47283 }
47284 {
47285 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
47286 }
47287 {
47288 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
47289 }
47290 {
47291 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
47292 }
47293 {
47294 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
47295 }
47296 {
47297 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
47298 }
47299 {
47300 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
47301 }
47302 {
47303 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
47304 }
47305 {
47306 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
47307 }
47308 {
47309 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
47310 }
47311 {
47312 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
47313 }
47314 {
47315 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
47316 }
47317 {
47318 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
47319 }
47320 {
47321 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
47322 }
47323 {
47324 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
47325 }
47326 {
47327 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
47328 }
47329 {
47330 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
47331 }
47332 {
47333 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
47334 }
47335 {
47336 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
47337 }
47338 {
47339 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
47340 }
47341 {
47342 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
47343 }
47344 {
47345 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
47346 }
47347 {
47348 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
47349 }
47350 {
47351 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
47352 }
47353 {
47354 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
47355 }
47356 {
47357 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
47358 }
47359 {
47360 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
47361 }
47362 {
47363 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
47364 }
47365 {
47366 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
47367 }
47368 {
47369 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
47370 }
47371 {
47372 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
47373 }
47374 {
47375 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
47376 }
47377 {
47378 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
47379 }
47380 {
47381 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
47382 }
47383 {
47384 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
47385 }
47386 {
47387 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
47388 }
47389 {
47390 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
47391 }
47392 {
47393 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
47394 }
47395 {
47396 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
47397 }
47398 {
47399 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
47400 }
47401 {
47402 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
47403 }
47404 {
47405 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
47406 }
47407 {
47408 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
47409 }
47410 {
47411 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
47412 }
47413 {
47414 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
47415 }
47416 {
47417 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
47418 }
47419 {
47420 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
47421 }
47422 {
47423 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
47424 }
47425 {
47426 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
47427 }
47428 {
47429 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
47430 }
47431 {
47432 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
47433 }
47434 {
47435 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
47436 }
47437 {
47438 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
47439 }
47440 {
47441 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
47442 }
47443 {
47444 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
47445 }
47446 {
47447 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
47448 }
47449 {
47450 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
47451 }
47452 {
47453 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
47454 }
47455 {
47456 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
47457 }
47458 {
47459 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
47460 }
47461 {
47462 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
47463 }
47464 {
47465 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
47466 }
47467 {
47468 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
47469 }
47470 {
47471 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
47472 }
47473 {
47474 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
47475 }
47476 {
47477 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
47478 }
47479 {
47480 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
47481 }
47482 {
47483 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
47484 }
47485 {
47486 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
47487 }
47488 {
47489 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
47490 }
47491 {
47492 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
47493 }
47494 {
47495 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
47496 }
47497 {
47498 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
47499 }
47500 {
47501 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
47502 }
47503 {
47504 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
47505 }
47506 {
47507 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
47508 }
47509 {
47510 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
47511 }
47512 {
47513 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
47514 }
47515 {
47516 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
47517 }
47518 {
47519 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
47520 }
47521 {
47522 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
47523 }
47524 {
47525 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
47526 }
47527 {
47528 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
47529 }
47530 {
47531 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
47532 }
47533 {
47534 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
47535 }
47536 {
47537 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
47538 }
47539 {
47540 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
47541 }
47542 {
47543 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
47544 }
47545 {
47546 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
47547 }
47548 {
47549 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
47550 }
47551 {
47552 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
47553 }
47554 {
47555 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
47556 }
47557 {
47558 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
47559 }
47560 {
47561 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
47562 }
47563 {
47564 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
47565 }
47566 {
47567 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
47568 }
47569 {
47570 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
47571 }
47572 {
47573 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
47574 }
47575 {
47576 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
47577 }
47578 {
47579 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
47580 }
47581 {
47582 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
47583 }
47584 {
47585 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
47586 }
47587 {
47588 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
47589 }
47590 {
47591 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
47592 }
47593 {
47594 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
47595 }
47596 {
47597 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
47598 }
47599 {
47600 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
47601 }
47602 {
47603 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
47604 }
47605 {
47606 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
47607 }
47608 {
47609 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
47610 }
47611 {
47612 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
47613 }
47614 {
47615 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
47616 }
47617 {
47618 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
47619 }
47620 {
47621 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
47622 }
47623 {
47624 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
47625 }
47626 {
47627 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
47628 }
47629 {
47630 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
47631 }
47632 {
47633 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
47634 }
47635 {
47636 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
47637 }
47638 {
47639 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
47640 }
47641 {
47642 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
47643 }
47644 {
47645 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
47646 }
47647 {
47648 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
47649 }
47650 {
47651 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
47652 }
47653 {
47654 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
47655 }
47656 {
47657 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
47658 }
47659 {
47660 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
47661 }
47662 {
47663 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
47664 }
47665 {
47666 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
47667 }
47668 {
47669 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
47670 }
47671 {
47672 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
47673 }
47674 {
47675 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
47676 }
47677 {
47678 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
47679 }
47680 {
47681 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
47682 }
47683 {
47684 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
47685 }
47686 {
47687 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
47688 }
47689 {
47690 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
47691 }
47692 {
47693 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
47694 }
47695 {
47696 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
47697 }
47698 {
47699 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
47700 }
47701 {
47702 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
47703 }
47704 {
47705 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
47706 }
47707 {
47708 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
47709 }
47710 {
47711 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
47712 }
47713 {
47714 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
47715 }
47716 {
47717 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
47718 }
47719 {
47720 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
47721 }
47722 {
47723 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
47724 }
47725 {
47726 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
47727 }
47728 {
47729 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
47730 }
47731 {
47732 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
47733 }
47734 {
47735 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
47736 }
47737 {
47738 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
47739 }
47740 {
47741 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
47742 }
47743 {
47744 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
47745 }
47746 {
47747 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
47748 }
47749 {
47750 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
47751 }
47752 {
47753 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
47754 }
47755 {
47756 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
47757 }
47758 {
47759 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
47760 }
47761 {
47762 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
47763 }
47764 {
47765 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
47766 }
47767 {
47768 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
47769 }
47770 {
47771 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
47772 }
47773 {
47774 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
47775 }
47776 {
47777 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
47778 }
47779 {
47780 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
47781 }
47782 {
47783 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
47784 }
47785 {
47786 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
47787 }
47788 {
47789 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
47790 }
47791 {
47792 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
47793 }
47794 {
47795 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
47796 }
47797 {
47798 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
47799 }
47800 {
47801 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
47802 }
47803 {
47804 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
47805 }
47806 {
47807 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
47808 }
47809 {
47810 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
47811 }
47812 {
47813 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
47814 }
47815 {
47816 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
47817 }
47818 {
47819 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
47820 }
47821 {
47822 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
47823 }
47824 {
47825 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
47826 }
47827 {
47828 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
47829 }
47830 {
47831 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
47832 }
47833 {
47834 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
47835 }
47836 {
47837 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
47838 }
47839 {
47840 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
47841 }
47842 {
47843 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
47844 }
47845 {
47846 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
47847 }
47848 {
47849 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
47850 }
47851 {
47852 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
47853 }
47854 {
47855 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
47856 }
47857 {
47858 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
47859 }
47860 {
47861 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
47862 }
47863 {
47864 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
47865 }
47866 {
47867 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
47868 }
47869 {
47870 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
47871 }
47872 {
47873 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
47874 }
47875 {
47876 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
47877 }
47878 {
47879 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
47880 }
47881 {
47882 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
47883 }
47884 {
47885 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
47886 }
47887 {
47888 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
47889 }
47890 {
47891 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
47892 }
47893 {
47894 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
47895 }
47896 {
47897 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
47898 }
47899 {
47900 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
47901 }
47902 {
47903 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
47904 }
47905 {
47906 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
47907 }
47908 {
47909 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
47910 }
47911 {
47912 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
47913 }
47914 {
47915 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
47916 }
47917 {
47918 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
47919 }
47920 {
47921 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
47922 }
47923 {
47924 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
47925 }
47926 {
47927 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
47928 }
47929 {
47930 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
47931 }
47932 {
47933 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
47934 }
47935 {
47936 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
47937 }
47938 {
47939 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
47940 }
47941 {
47942 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
47943 }
47944 {
47945 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
47946 }
47947 {
47948 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
47949 }
47950 {
47951 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
47952 }
47953 {
47954 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
47955 }
47956 {
47957 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
47958 }
47959 {
47960 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
47961 }
47962 {
47963 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
47964 }
47965 {
47966 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
47967 }
47968 {
47969 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
47970 }
47971 {
47972 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
47973 }
47974 {
47975 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
47976 }
47977 {
47978 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
47979 }
47980 {
47981 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
47982 }
47983 {
47984 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
47985 }
47986 {
47987 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
47988 }
47989 {
47990 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
47991 }
47992 {
47993 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
47994 }
47995 {
47996 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
47997 }
47998 {
47999 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
48000 }
48001 {
48002 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
48003 }
48004 {
48005 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
48006 }
48007 {
48008 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
48009 }
48010 {
48011 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
48012 }
48013 {
48014 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
48015 }
48016 {
48017 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
48018 }
48019 {
48020 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
48021 }
48022 {
48023 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
48024 }
48025 {
48026 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
48027 }
48028 {
48029 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
48030 }
48031 {
48032 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
48033 }
48034 {
48035 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
48036 }
48037 {
48038 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
48039 }
48040 {
48041 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
48042 }
48043 {
48044 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
48045 }
48046 {
48047 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
48048 }
48049 {
48050 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
48051 }
48052 {
48053 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
48054 }
48055 {
48056 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
48057 }
48058 {
48059 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
48060 }
48061 {
48062 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
48063 }
48064 {
48065 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
48066 }
48067 {
48068 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
48069 }
48070 {
48071 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
48072 }
48073 {
48074 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
48075 }
48076 {
48077 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
48078 }
48079 {
48080 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
48081 }
48082 {
48083 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
48084 }
48085 {
48086 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
48087 }
48088 {
48089 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
48090 }
48091 {
48092 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
48093 }
48094 {
48095 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
48096 }
48097 {
48098 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
48099 }
48100 {
48101 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
48102 }
48103 {
48104 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
48105 }
48106 {
48107 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
48108 }
48109 {
48110 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
48111 }
48112 {
48113 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
48114 }
48115 {
48116 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
48117 }
48118 {
48119 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
48120 }
48121 {
48122 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
48123 }
48124 {
48125 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
48126 }
48127 {
48128 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
48129 }
48130 {
48131 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
48132 }
48133 {
48134 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
48135 }
48136 {
48137 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
48138 }
48139 {
48140 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
48141 }
48142 {
48143 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
48144 }
48145 {
48146 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
48147 }
48148 {
48149 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
48150 }
48151 {
48152 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
48153 }
48154 {
48155 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
48156 }
48157 {
48158 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
48159 }
48160 {
48161 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
48162 }
48163 {
48164 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
48165 }
48166 {
48167 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
48168 }
48169 {
48170 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
48171 }
48172 {
48173 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
48174 }
48175 {
48176 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
48177 }
48178 {
48179 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
48180 }
48181 {
48182 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
48183 }
48184 {
48185 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
48186 }
48187 {
48188 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
48189 }
48190 {
48191 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
48192 }
48193 {
48194 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
48195 }
48196 {
48197 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
48198 }
48199 {
48200 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
48201 }
48202 {
48203 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
48204 }
48205 {
48206 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
48207 }
48208 {
48209 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
48210 }
48211 {
48212 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
48213 }
48214 {
48215 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
48216 }
48217 {
48218 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
48219 }
48220 {
48221 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
48222 }
48223 {
48224 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
48225 }
48226 {
48227 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
48228 }
48229 {
48230 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
48231 }
48232 {
48233 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
48234 }
48235 {
48236 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
48237 }
48238 {
48239 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
48240 }
48241 {
48242 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
48243 }
48244 {
48245 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
48246 }
48247 {
48248 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
48249 }
48250 {
48251 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
48252 }
48253 {
48254 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
48255 }
48256 {
48257 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
48258 }
48259 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
48260 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
48261 {
48262 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
48263 }
48264 {
48265 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
48266 }
48267 {
48268 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
48269 }
48270 {
48271 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
48272 }
48273 {
48274 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
48275 }
48276 {
48277 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
48278 }
48279 {
48280 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
48281 }
48282 {
48283 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
48284 }
48285 {
48286 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
48287 }
48288 {
48289 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
48290 }
48291 {
48292 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
48293 }
48294 {
48295 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
48296 }
48297 {
48298 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
48299 }
48300 {
48301 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
48302 }
48303 {
48304 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
48305 }
48306 {
48307 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
48308 }
48309 {
48310 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
48311 }
48312 {
48313 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
48314 }
48315 {
48316 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
48317 }
48318 {
48319 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
48320 }
48321 {
48322 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
48323 }
48324 {
48325 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
48326 }
48327 {
48328 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
48329 }
48330 {
48331 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
48332 }
48333 {
48334 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
48335 }
48336 {
48337 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
48338 }
48339 {
48340 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
48341 }
48342 {
48343 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
48344 }
48345 {
48346 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
48347 }
48348 {
48349 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
48350 }
48351 {
48352 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
48353 }
48354 {
48355 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
48356 }
48357 {
48358 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
48359 }
48360 {
48361 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
48362 }
48363 {
48364 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
48365 }
48366 {
48367 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
48368 }
48369 {
48370 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
48371 }
48372 {
48373 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
48374 }
48375 {
48376 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
48377 }
48378 {
48379 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
48380 }
48381 {
48382 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
48383 }
48384 {
48385 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
48386 }
48387 {
48388 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
48389 }
48390 {
48391 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
48392 }
48393 {
48394 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
48395 }
48396 {
48397 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
48398 }
48399 {
48400 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
48401 }
48402 {
48403 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
48404 }
48405 {
48406 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
48407 }
48408 {
48409 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
48410 }
48411 {
48412 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
48413 }
48414 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
48415 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
48416 {
48417 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
48418 }
48419 {
48420 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
48421 }
48422 {
48423 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
48424 }
48425
48426 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
48427
48428
48429 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
48430
48431 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
48432 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
48433 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
48434 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
48435 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
48436 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
48437 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
48438 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
48439 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
48440 {
48441 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
48442 }
48443 {
48444 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
48445 }
48446 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
48447 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
48448 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
48449 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
48450 {
48451 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
48452 }
48453 {
48454 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
48455 }
48456 {
48457 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
48458 }
48459 {
48460 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
48461 }
48462 {
48463 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
48464 }
48465 {
48466 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
48467 }
48468 {
48469 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
48470 }
48471 {
48472 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
48473 }
48474 {
48475 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
48476 }
48477 {
48478 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
48479 }
48480 {
48481 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
48482 }
48483 {
48484 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
48485 }
48486 {
48487 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
48488 }
48489 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
48490 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
48491 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
48492 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
48493 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
48494 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
48495 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
48496 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
48497 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
48498 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
48499 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
48500 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
48501 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
48502 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
48503 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
48504 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
48505 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
48506 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
48507 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
48508 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
48509 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
48510 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
48511 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
48512 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
48513 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
48514 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
48515 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
48516 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
48517 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
48518 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
48519 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
48520 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
48521 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
48522 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
48523 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
48524 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
48525 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
48526 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
48527 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
48528 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
48529 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
48530 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
48531 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
48532 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
48533 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
48534 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
48535 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
48536 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
48537 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
48538 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
48539 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
48540 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
48541 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
48542 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
48543 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
48544 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
48545 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
48546 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
48547 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
48548 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
48549 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
48550 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
48551 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
48552 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
48553 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
48554 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
48555 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
48556 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
48557 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
48558 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
48559 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
48560 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
48561 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
48562 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
48563 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
48564 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
48565 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
48566 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
48567 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
48568 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
48569 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
48570 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
48571 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
48572 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
48573 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
48574 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
48575 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
48576 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
48577 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
48578 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
48579 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
48580 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
48581 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
48582 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
48583 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
48584 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
48585 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
48586 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
48587 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
48588 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
48589 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
48590 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
48591 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
48592 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
48593 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
48594 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
48595 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
48596 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
48597 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
48598 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
48599 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
48600 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
48601 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
48602 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
48603 {
48604 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
48605 }
48606 {
48607 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
48608 }
48609 {
48610 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
48611 }
48612 {
48613 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
48614 }
48615 {
48616 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
48617 }
48618 {
48619 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
48620 }
48621 {
48622 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
48623 }
48624 {
48625 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
48626 }
48627 {
48628 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
48629 }
48630 {
48631 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
48632 }
48633 {
48634 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
48635 }
48636 {
48637 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
48638 }
48639 {
48640 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
48641 }
48642 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
48643 {
48644 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
48645 }
48646 {
48647 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
48648 }
48649 {
48650 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
48651 }
48652 {
48653 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
48654 }
48655 {
48656 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
48657 }
48658 {
48659 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
48660 }
48661 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
48662 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
48663 {
48664 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
48665 }
48666 {
48667 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
48668 }
48669 {
48670 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
48671 }
48672 {
48673 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
48674 }
48675 {
48676 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
48677 }
48678 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
48679 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
48680 {
48681 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
48682 }
48683 {
48684 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
48685 }
48686 {
48687 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
48688 }
48689 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
48690 {
48691 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
48692 }
48693 {
48694 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
48695 }
48696 {
48697 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
48698 }
48699 {
48700 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
48701 }
48702 {
48703 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
48704 }
48705 {
48706 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
48707 }
48708 {
48709 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
48710 }
48711 {
48712 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
48713 }
48714 {
48715 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
48716 }
48717 {
48718 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
48719 }
48720 {
48721 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
48722 }
48723 {
48724 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
48725 }
48726 {
48727 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
48728 }
48729 {
48730 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
48731 }
48732 {
48733 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
48734 }
48735 {
48736 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
48737 }
48738 {
48739 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
48740 }
48741 {
48742 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
48743 }
48744 {
48745 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
48746 }
48747
48748 // Initialize threading, some globals and such
48749 __wxPyPreStart(d);
48750
48751
48752 // Although these are defined in __version__ they need to be here too so
48753 // that an assert can be done to ensure that the wxPython and the wxWindows
48754 // versions match.
48755 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
48756 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
48757 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
48758
48759 }
48760
wxWidgets (Impactor)